Deadlock

A deadlock is a state where two or more threads are blocked forever, each waiting for a lock held by the other. Preventing deadlocks requires understanding resource acquisition orders.

The Four Coffman Conditions

All four conditions must hold simultaneously for a deadlock to occur:

1. Mutual Exclusion: At least one resource must be held in a non-shareable mode (only one thread can hold it).
2. Hold and Wait: A thread must hold at least one lock and be waiting for another lock held by another thread.
3. No Preemption: Locks cannot be forcibly taken from a thread; they must be released voluntarily.
4. Circular Wait: Thread 1 waits for a lock held by Thread 2, who waits for a lock held by Thread 3, who waits for a lock held by Thread 1.

Code Walkthrough

The following example demonstrates how a deadlock occurs and how ordering lock acquisition resolves it.

public class DeadlockDemo {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();
public static void main(String[] args) {
        // Deadlocked thread: locks lock1 then lock2
        new Thread(() -> {
            synchronized (lock1) {
                try { Thread.sleep(50); } catch (InterruptedException e) {}
                synchronized (lock2) {
                    System.out.println("Thread 1 acquired both locks");
                }
            }
        }).start();
// Conflicting thread: locks lock2 then lock1 -> Deadlock!
        new Thread(() -> {
            synchronized (lock2) {
                try { Thread.sleep(50); } catch (InterruptedException e) {}
                synchronized (lock1) {
                    System.out.println("Thread 2 acquired both locks");
                }
            }
        }).start();
// FIX: Ensure both threads acquire locks in the exact same order: lock1 first, then lock2.
    }
}

Interview-Relevant Information