什么是死锁？
死锁是一种特殊的情况，发生在两个或多个线程彼此等待对方持有的资源，从而陷入无限等待的状态。具体而言，死锁通常涉及以下四个必要条件：
- 互斥条件：至少有一个资源被一个线程独占。
- 持有并等待：至少有一个线程持有资源，并等待获取由其他线程持有的资源。
- 不剥夺条件：资源不能被强制性剥夺，必须由持有它的线程自愿释放。
- 循环等待：存在一个线程循环等待链，即
T1等待T2持有的资源，T2等待T3持有的资源，直到Tn等待T1持有的资源。
常见的死锁场景
场景一：嵌套锁（Nested Locks）
最常见的死锁场景之一是嵌套锁。例如，线程 A 拥有锁 1，线程 B 拥有锁 2，接下来：
- 线程 A 尝试获取锁 2，但锁 2 被线程 B 持有。
- 线程 B 尝试获取锁 1，但锁 1 被线程 A 持有。
public class DeadlockExample {private final Object lock1 = new Object();private final Object lock2 = new Object();public void method1() {synchronized (lock1) {System.out.println("Thread 1: Holding lock 1...");try { Thread.sleep(10); } catch (InterruptedException e) {}System.out.println("Thread 1: Waiting for lock 2...");synchronized (lock2) {System.out.println("Thread 1: Holding lock 1 & 2...");}}}public void method2() {synchronized (lock2) {System.out.println("Thread 2: Holding lock 2...");try { Thread.sleep(10); } catch (InterruptedException e) {}System.out.println("Thread 2: Waiting for lock 1...");synchronized (lock1) {System.out.println("Thread 2: Holding lock 1 & 2...");}}}public static void main(String[] args) {DeadlockExample example = new DeadlockExample();new Thread(example::method1).start();new Thread(example::method2).start();}
}
场景二：资源分配不当
线程在获取多个资源时，如果不按顺序获取资源，可能导致死锁。例如，线程 A 和线程 B 同时尝试获取资源 R1 和 R2：
public class ResourceAllocationDeadlock {private final Object resource1 = new Object();private final Object resource2 = new Object();public void process1() {synchronized (resource1) {System.out.println("Thread 1: Locked resource 1");try { Thread.sleep(50); } catch (InterruptedException e) {}synchronized (resource2) {System.out.println("Thread 1: Locked resource 2");}}}public void process2() {synchronized (resource2) {System.out.println("Thread 2: Locked resource 2");try { Thread.sleep(50); } catch (InterruptedException e) {}synchronized (resource1) {System.out.println("Thread 2: Locked resource 1");}}}public static void main(String[] args) {ResourceAllocationDeadlock example = new ResourceAllocationDeadlock();new Thread(example::process1).start();new Thread(example::process2).start();}
}
死锁检测与诊断
使用 jStack 工具
Java 提供了强大的工具如 jStack 来检测死锁。jStack 是一个命令行工具，可以生成 Java 虚拟机中线程的堆栈跟踪。通过分析这些堆栈跟踪，我们可以确定是否存在死锁以及死锁的具体位置。
生成堆栈跟踪的命令如下：
jstack <pid>
输出示例：
Found one Java-level deadlock:
=============================
"Thread-1":waiting to lock monitor 0x00007f8a5404e5c8 (object 0x0000000780e02870, a java.lang.Object),which is held by "Thread-2"
"Thread-2":waiting to lock monitor 0x00007f8a5404e608 (object 0x0000000780e02890, a java.lang.Object),which is held by "Thread-1"
使用 ThreadMXBean
Java 还提供了 ThreadMXBean 类来检测和诊断死锁。以下示例演示了如何使用 ThreadMXBean 来检测死锁：
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;public class DeadlockDetector {private final Object lock1 = new Object();private final Object lock2 = new Object();public void method1() {synchronized (lock1) {try { Thread.sleep(100); } catch (InterruptedException e) {}synchronized (lock2) {}}}public void method2() {synchronized (lock2) {try { Thread.sleep(100); } catch (InterruptedException e) {}synchronized (lock1) {}}}public static void main(String[] args) {DeadlockDetector example = new DeadlockDetector();new Thread(example::method1).start();new Thread(example::method2).start();ThreadMXBean bean = ManagementFactory.getThreadMXBean();long[] threadIds = bean.findDeadlockedThreads();if (threadIds != null) {ThreadInfo[] infos = bean.getThreadInfo(threadIds);for (ThreadInfo info : infos) {System.out.println("Deadlock detected:");System.out.println(info);}} else {System.out.println("No deadlock detected.");}}
}
预防死锁的策略
1. 避免嵌套锁
减少嵌套锁的使用可以有效降低死锁的风险。通过简化锁的获取逻辑，确保每个线程在获取锁时不会依赖于其他锁，可以大大减少死锁的发生。
2. 遵循锁顺序
在多个线程需要访问多个资源时，确保所有线程按照相同的顺序获取锁。例如，如果所有线程都按照先获取 lock1 再获取 lock2 的顺序来获取锁，则可以避免循环等待，从而防止死锁。
public class LockOrder {private final Object lock1 = new Object();private final Object lock2 = new Object();public void process1() {synchronized (lock1) {synchronized (lock2) {System.out.println("Thread 1: Locked resource 1 and 2");}}}public void process2() {synchronized (lock1) {synchronized (lock2) {System.out.println("Thread 2: Locked resource 1 and 2");}}}public static void main(String[] args) {LockOrder example = new LockOrder();new Thread(example::process1).start();new Thread(example::process2).start();}
}
3. 使用超时机制
在尝试获取锁时使用超时机制，可以避免线程无限期等待，从而降低死锁的风险。Java 提供了 Lock 接口的 tryLock 方法，可以指定等待锁的时间：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;public class TimeoutLock {private final Lock lock1 = new ReentrantLock();private final Lock lock2 = new ReentrantLock();public void process1() {try {if (lock1.tryLock(50, TimeUnit.MILLISECONDS)) {try {if (lock2.tryLock(50, TimeUnit.MILLISECONDS)) {try {System.out.println("Thread 1: Locked resource 1 and 2");} finally {lock2.unlock();}}} finally {lock1.unlock();}}} catch (InterruptedException e) {e.printStackTrace();}}public void process2() {try {if (lock2.tryLock(50, TimeUnit.MILLISECONDS)) {try {if (lock1.tryLock(50, TimeUnit.MILLISECONDS)) {try {System.out.println("Thread 2: Locked resource1 and 2");} finally {lock1.unlock();}}} finally {lock2.unlock();}}} catch (InterruptedException e) {e.printStackTrace();}}public static void main(String[] args) {TimeoutLock example = new TimeoutLock();new Thread(example::process1).start();new Thread(example::process2).start();}
}
4. 使用更高级的并发工具
Java 的 java.util.concurrent 包提供了多种高级并发工具，如 Semaphore、CountDownLatch、CyclicBarrier 等，可以有效管理线程之间的交互，从而降低死锁的风险。
例如，使用 Semaphore 控制资源访问：
import java.util.concurrent.Semaphore;public class SemaphoreExample {private final Semaphore semaphore = new Semaphore(1);public void process() {try {semaphore.acquire();System.out.println(Thread.currentThread().getName() + " acquired semaphore");try { Thread.sleep(100); } catch (InterruptedException e) {}} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println(Thread.currentThread().getName() + " releasing semaphore");semaphore.release();}}public static void main(String[] args) {SemaphoreExample example = new SemaphoreExample();new Thread(example::process).start();new Thread(example::process).start();}
}
5. 避免过度锁定
尽量减少锁的持有时间和锁的粒度，避免在持有锁时进行长时间操作，如 I/O 操作或长时间计算。这样可以减少线程等待的机会，从而降低死锁的风险。
解决死锁的策略
1. 死锁检测与恢复
在一些关键系统中，可以定期运行死锁检测算法，一旦发现死锁，强制释放某些资源或重启部分线程以恢复系统运行。
2. 修改锁的获取顺序
在检测到死锁后，可以尝试修改线程获取锁的顺序，使得不会形成循环等待。具体实施时可以参考预防死锁时的锁顺序策略。
3. 重新设计系统架构
如果死锁问题频繁出现，可以考虑重新设计系统架构，通过调整线程模型和资源管理策略，从根本上避免死锁。例如，采用无锁并发数据结构或事件驱动模型等。
结论
死锁是多线程编程中常见且棘手的问题，但通过合理的设计和策略，可以有效预防和解决死锁。本文介绍了死锁的基本概念、常见场景、检测与诊断方法，以及预防和解决死锁的多种策略。希望这些内容能帮助开发者在实际项目中更好地应对死锁问题，提高系统的稳定性和可靠性。
