What is a deadlock in Java? How do you prevent it?

In Java, a deadlock occurs when two or more threads are blocked, waiting for each other to release the resources they need to proceed further. In other words, a deadlock happens when two or more threads are stuck in a cycle of waiting for each other to finish their work, resulting in a situation where no thread can make progress. This can cause a program to become unresponsive, causing performance issues and potentially even crashing the application.

Here is an example of a deadlock scenario:

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

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Locked resource 2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource1) {
                    System.out.println("Thread 2: Locked resource 1");
                }
            }
        });

        t1.start();
        t2.start();
    }
}

In this example, two threads are competing for two resources in opposite order, which causes a deadlock. The first thread acquires resource1 and then waits for resource2, while the second thread acquires resource2 and then waits for resource1. As a result, both threads are blocked, waiting for each other to release the resources they need to proceed further.

To prevent a deadlock, we can follow some best practices such as avoiding nested locks, ensuring that all threads acquire locks in the same order, and using a timeout for locks. Additionally, using a thread-safe collection, like ConcurrentHashMap instead of a regular HashMap can also help prevent deadlocks.