死锁原理与预防
什么是死锁？
死锁（Deadlock）是多线程编程中常见的问题，指的是两个或多个线程在执行过程中，因为争夺资源而造成的一种互相等待的现象。如果没有外部干预，这些线程将永远无法继续执行下去。
死锁通常发生在多个线程需要同时持有多个锁的情况下。如果每个线程都持有一个锁，并且试图获取另一个线程已经持有的锁，那么它们就会陷入死锁状态。
死锁的四个必要条件
死锁的发生需要满足以下四个条件，通常称为“死锁四要素”：
- 互斥条件：资源一次只能被一个线程占用。
- 占有并等待：线程已经持有了至少一个资源，并且正在等待获取其他被占用的资源。
- 非抢占条件：线程已经持有的资源不能被其他线程强行抢占，必须由线程自行释放。
- 循环等待条件：存在一个线程等待的循环链，每个线程都在等待下一个线程所持有的资源。
只有当这四个条件同时满足时，死锁才会发生。
死锁的代码示例
以下是一个简单的死锁示例，展示了两个线程互相等待对方释放锁的情况：
public class DeadlockExample {
private static final Object lock1 = new Object();
private static final Object lock2 = new Object();
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (lock1) {
System.out.println("Thread 1: Holding lock 1...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) {
System.out.println("Thread 1: Holding lock 1 and lock 2...");
}
}
});
Thread thread2 = new Thread(() -> {
synchronized (lock2) {
System.out.println("Thread 2: Holding lock 2...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
System.out.println("Thread 2: Waiting for lock 1...");
synchronized (lock1) {
System.out.println("Thread 2: Holding lock 2 and lock 1...");
}
}
});
thread1.start();
thread2.start();
}
}
输出结果
Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...
在这个例子中，thread1持有lock1并试图获取lock2，而thread2持有lock2并试图获取lock1。由于两个线程都在等待对方释放锁，因此它们陷入了死锁状态。
如何预防死锁？
要预防死锁，我们需要打破死锁的四个必要条件中的至少一个。以下是几种常见的预防死锁的策略：
1. 避免嵌套锁
尽量避免在持有一个锁的同时去获取另一个锁。如果必须使用多个锁，确保所有线程以相同的顺序获取锁。
2. 使用超时机制
在获取锁时设置超时时间。如果线程在指定时间内无法获取锁，则放弃并释放已经持有的锁，然后重试。
3. 使用锁排序
为所有锁定义一个全局的获取顺序，并要求所有线程按照这个顺序获取锁。这样可以避免循环等待的发生。
4. 使用高级并发工具
Java 提供了许多高级并发工具，如java.util.concurrent包中的ReentrantLock和Semaphore，它们可以帮助你更灵活地管理锁和资源。
实际案例：银行转账
假设我们有一个银行系统，需要处理多个账户之间的转账操作。每个账户都有一个锁，用于保护账户余额的并发访问。如果我们不小心处理锁的顺序，就可能导致死锁。
public class BankTransfer {
private static final Object lock1 = new Object();
private static final Object lock2 = new Object();
public static void transfer(Object fromAccount, Object toAccount, double amount) {
synchronized (fromAccount) {
synchronized (toAccount) {
// 执行转账操作
System.out.println("Transfer complete: " + amount);
}
}
}
public static void main(String[] args) {
Thread thread1 = new Thread(() -> transfer(lock1, lock2, 100.0));
Thread thread2 = new Thread(() -> transfer(lock2, lock1, 200.0));
thread1.start();
thread2.start();
}
}
在这个例子中，如果thread1和thread2同时执行转账操作，它们可能会互相等待对方释放锁，从而导致死锁。
解决方案：锁排序
为了避免死锁，我们可以为账户定义一个唯一的排序规则，例如按照账户的哈希值排序，然后按照这个顺序获取锁。
public class BankTransfer {
private static final Object lock1 = new Object();
private static final Object lock2 = new Object();
public static void transfer(Object fromAccount, Object toAccount, double amount) {
Object firstLock = fromAccount.hashCode() < toAccount.hashCode() ? fromAccount : toAccount;
Object secondLock = fromAccount.hashCode() < toAccount.hashCode() ? toAccount : fromAccount;
synchronized (firstLock) {
synchronized (secondLock) {
// 执行转账操作
System.out.println("Transfer complete: " + amount);
}
}
}
public static void main(String[] args) {
Thread thread1 = new Thread(() -> transfer(lock1, lock2, 100.0));
Thread thread2 = new Thread(() -> transfer(lock2, lock1, 200.0));
thread1.start();
thread2.start();
}
}
通过这种方式，我们可以确保所有线程都按照相同的顺序获取锁，从而避免死锁的发生。
总结
死锁是多线程编程中一个常见且棘手的问题。了解死锁的原理及其四个必要条件，可以帮助我们更好地识别和预防死锁。通过避免嵌套锁、使用超时机制、锁排序和高级并发工具，我们可以有效地减少死锁的发生。
附加资源与练习
- 练习：尝试修改上面的银行转账示例，使其能够处理多个账户之间的并发转账操作，并确保不会发生死锁。
- 进一步阅读：阅读 Java 官方文档中关于
java.util.concurrent包的介绍，了解更多关于并发工具的使用方法。
记住，预防死锁的关键在于设计良好的锁策略和资源管理。在编写多线程程序时，始终要考虑到潜在的并发问题，并采取适当的预防措施。