Deadlock

A deadlock occurs when two or more threads are each waiting for a resource (usually a lock) held by another thread in the same cycle, so none of them can ever proceed. Once a deadlock happens, the affected threads are stuck permanently — the JVM does not automatically detect or break deadlocks involving intrinsic locks.

Why it matters

A deadlock does not throw an exception or print an error. The affected threads simply stop, forever, usually under load and often only in production. Knowing the conditions that make it possible lets you design it out — the simplest rule, always taking locks in the same order, prevents most cases.

The Four Necessary Conditions

Classic operating-systems theory identifies four conditions that must all hold simultaneously for a deadlock to occur. If any one of them is broken, deadlock becomes impossible.

• Mutual exclusion — a resource (lock) can be held by only one thread at a time.
• Hold and wait — a thread holds at least one resource while waiting to acquire another.
• No preemption — a resource cannot be forcibly taken from a thread; it must be released voluntarily.
• Circular wait — a cycle of threads exists where each is waiting for a resource held by the next thread in the cycle.

A Concrete Two-Lock Deadlock

The most common real-world deadlock shape happens when two threads each need two locks, but acquire them in opposite order: Thread A locks Resource 1 then tries to lock Resource 2, while Thread B locks Resource 2 then tries to lock Resource 1. If both threads acquire their first lock at nearly the same time, each ends up waiting forever for a lock the other one holds.

Prevention Strategies

Deadlock is prevented by breaking one of the four necessary conditions, and in practice the most common techniques are consistent lock ordering and using timed lock attempts instead of indefinite blocking.

• Lock ordering — always acquire multiple locks in the same global order across every thread, which eliminates circular wait.
• Lock timeouts — use java.util.concurrent.locks.Lock.tryLock(timeout, unit) instead of synchronized so a thread can back off and retry rather than block forever.
• Minimizing lock scope — hold locks for the shortest time possible and avoid acquiring a second lock while already holding one, whenever the logic allows it.
• Using higher-level concurrency utilities — classes in java.util.concurrent (like ConcurrentHashMap or BlockingQueue) avoid manual multi-lock coordination entirely.

Example

public class DeadlockDemo {
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("Thread-1 locked A, waiting for B");
                try { Thread.sleep(100); } catch (InterruptedException ignored) {}
                synchronized (lockB) {
                    System.out.println("Thread-1 acquired both locks");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("Thread-2 locked B, waiting for A");
                try { Thread.sleep(100); } catch (InterruptedException ignored) {}
                synchronized (lockA) {
                    System.out.println("Thread-2 acquired both locks");
                }
            }
        });

        t1.start();
        t2.start();
        // Both threads print their first line, then block forever waiting on
        // each other's lock. "acquired both locks" never prints for either thread.
    }
}

Thread-1 locked A, waiting for B
Thread-2 locked B, waiting for A
(The program then hangs indefinitely — a genuine deadlock. Fixing it means having both threads
acquire lockA before lockB, i.e. a consistent global lock order.)

Exercise

These two threads take the same two locks in opposite orders, so the program can hang. Change the second thread so that both threads acquire the locks in the same order. The program then always finishes.

Expected output: done

public class LockOrder {
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread first = new Thread(() -> {
            synchronized (lockA) {
                synchronized (lockB) {
                    // work using both locks
                }
            }
        });

        Thread second = new Thread(() -> {
            synchronized (lockB) {
                synchronized (lockA) {
                    // work using both locks
                }
            }
        });

        first.start();
        second.start();
        first.join();
        second.join();
        System.out.println("done");
    }
}

public class LockOrder {
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread first = new Thread(() -> {
            synchronized (lockA) {
                synchronized (lockB) {
                    // work using both locks
                }
            }
        });

        Thread second = new Thread(() -> {
            synchronized (lockA) {
                synchronized (lockB) {
                    // work using both locks
                }
            }
        });

        first.start();
        second.start();
        first.join();
        second.join();
        System.out.println("done");
    }
}

Quick quiz

Interview questions