Understanding Java Deadlocks: Causes, Impact, and a Guaranteed Deadlock Example

The article introduces deadlocks, explaining that they occur in concurrent scenarios when two or more threads hold resources the others need and refuse to release them, leading to indefinite blocking.

It describes the hazards of deadlocks, including system crashes, performance degradation, and especially their severe impact on database systems and the JVM, where deadlocks may halt execution without automatic recovery.

A concrete Java example that inevitably causes a deadlock is presented. Two locks are created, and two threads acquire them in opposite order, causing each thread to wait for the other's lock.

public class MustDeadLockDemo {

    public static void main(String[] args) {
        Object lock1 = new Object();
        Object lock2 = new Object();
        new Thread(new DeadLockTask(lock1, lock2, true), "线程1").start();
        new Thread(new DeadLockTask(lock1, lock2, false), "线程2").start();
    }

    static class DeadLockTask implements Runnable {
        private boolean flag;
        private Object lock1;
        private Object lock2;

        public DeadLockTask(Object lock1, Object lock2, boolean flag) {
            this.lock1 = lock1;
            this.lock2 = lock2;
            this.flag = flag;
        }

        @Override
        public void run() {
            if (flag) {
                synchronized (lock1) {
                    System.out.println(Thread.currentThread().getName() + "->拿到锁1");
                    try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
                    System.out.println(Thread.currentThread().getName() + "->等待锁2释放...");
                    synchronized (lock2) {
                        System.out.println(Thread.currentThread().getName() + "->拿到锁2");
                    }
                }
            }
            if (!flag) {
                synchronized (lock2) {
                    System.out.println(Thread.currentThread().getName() + "->拿到锁2");
                    try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
                    System.out.println(Thread.currentThread().getName() + "->等待锁1释放...");
                    synchronized (lock1) {
                        System.out.println(Thread.currentThread().getName() + "->拿到锁1");
                    }
                }
            }
        }
    }
}

Running this program shows both threads blocked, confirming the deadlock. The article then details step‑by‑step debugging using IDEA, setting breakpoints, and observing thread states to illustrate how the deadlock occurs.

Finally, it summarizes that deadlocks are probabilistic but can have severe consequences, especially in high‑concurrency environments, and advises developers to detect and avoid them during design and testing.

References are provided, including the book “Java Concurrency Programming 78 Lectures” by Xu Longxi.