In Java, a deadlock is a situation where two or more threads are blocked, waiting for each other to release a resource or lock, and as a result, none of the threads can proceed. Deadlocks can occur in multi-threaded programs when two or more threads are competing for the same resources and they each hold a resource that the other thread needs.

Here's an example of a simple deadlock scenario:

public class DeadlockDemo {
    private Object resource1 = new Object();
    private Object resource2 = new Object();

    public void method1() {
        synchronized (resource1) {
            synchronized (resource2) {
                // Do some work with resource1 and resource2
            }
        }
    }

    public void method2() {
        synchronized (resource2) {
            synchronized (resource1) {
                // Do some work with resource1 and resource2
            }
        }
    }
}

In this example, two threads are competing for the resource1 and resource2 objects, and they are each holding one of the resources. Thread 1 is holding resource1 and waiting for resource2, while Thread 2 is holding resource2 and waiting for resource1. As a result, both threads are blocked, and the program is in a deadlock state.

To prevent deadlocks in Java, you can follow some best practices such as:

1. Avoid holding multiple locks at the same time whenever possible.
2. Ensure that locks are acquired and released in a consistent order across all threads.
3. Use timeout values when acquiring locks to prevent indefinite blocking.
4. Use the tryLock() method of the Lock interface to avoid waiting indefinitely for a lock to become available.
5. Use higher-level concurrency utilities such as Executor, Semaphore, and Phaser instead of using low-level synchronization primitives like wait(), notify(), and synchronized.

It's important to note that preventing deadlocks in multi-threaded applications can be challenging, and it requires careful design and testing.