Java 死锁及破除死锁示例

Java 死锁及破除死锁示例

一、什么是死锁？

死锁是指多个线程在运行过程中因争夺资源而陷入相互等待的状态，导致程序无法继续执行。死锁的发生需要满足以下 四个必要条件：

1. 互斥条件：资源只能被一个线程占用。
2. 持有并等待：线程持有至少一个资源，同时等待其他资源。
3. 不可抢占：线程已持有的资源不能被强制剥夺。
4. 循环等待：存在线程间的循环等待链，如 A 等 B，B 等 A。

二、Java 死锁示例

以下是一个典型的死锁代码示例：

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

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("Thread 1: Holding lockA");
                try { Thread.sleep(100); } catch (Exception e) {}
                synchronized (lockB) {
                    System.out.println("Thread 1: Acquired lockB");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("Thread 2: Holding lockB");
                try { Thread.sleep(100); } catch (Exception e) {}
                synchronized (lockA) {
                    System.out.println("Thread 2: Acquired lockA");
                }
            }
        });

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

运行结果：程序卡住，无输出结束，两个线程互相等待对方释放锁。

三、破除死锁的常用方法

1. 破坏循环等待条件

强制所有线程按照 固定顺序获取锁，避免循环依赖。

// 修改后的代码：统一锁的获取顺序
Thread t1 = new Thread(() -> {
    synchronized (lockA) {
        System.out.println("Thread 1: Holding lockA");
        try { Thread.sleep(100); } catch (Exception e) {}
        synchronized (lockB) {
            System.out.println("Thread 1: Acquired lockB");
        }
    }
});

Thread t2 = new Thread(() -> {
    synchronized (lockA) {  // 先获取 lockA，与 t1 顺序一致
        System.out.println("Thread 2: Holding lockA");
        try { Thread.sleep(100); } catch (Exception e) {}
        synchronized (lockB) {
            System.out.println("Thread 2: Acquired lockB");
        }
    }
});

2. 使用超时机制（tryLock）

通过 ReentrantLock 的 tryLock 方法避免无限等待。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockFixDemo {
    static final Lock lockA = new ReentrantLock();
    static final Lock lockB = new ReentrantLock();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                if (lockA.tryLock(500, TimeUnit.MILLISECONDS)) {
                    System.out.println("Thread 1: Holding lockA");
                    try { Thread.sleep(100); } catch (Exception e) {}
                    if (lockB.tryLock(500, TimeUnit.MILLISECONDS)) {
                        System.out.println("Thread 1: Acquired lockB");
                        lockB.unlock();
                    }
                    lockA.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                if (lockB.tryLock(500, TimeUnit.MILLISECONDS)) {
                    System.out.println("Thread 2: Holding lockB");
                    try { Thread.sleep(100); } catch (Exception e) {}
                    if (lockA.tryLock(500, TimeUnit.MILLISECONDS)) {
                        System.out.println("Thread 2: Acquired lockA");
                        lockA.unlock();
                    }
                    lockB.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

3. 检测与恢复

通过监控工具（如 jstack、VisualVM）检测死锁，或设计线程释放资源的回退机制。

四、如何检测死锁？

1. 使用命令行工具：

   jstack <PID>  # 查看线程堆栈，分析死锁信息
   

2. 使用 VisualVM：监控线程状态，直接标记死锁位置。

五、总结

核心原则：在设计多线程程序时，优先预防死锁，而非事后修复。