Java 中什么情況會導致死鎖？如何避免？
在 Java編程中，死鎖是一種常見的多線程問題，它發生在兩個或多個線程彼此等待對方持有的資源時，導致這些線程都無法繼續執行。死鎖問題的解決和避免是多線程編程中的一個重要課題。這篇文章，我們一起來探討 Java中死鎖的情況及避免方法的詳細。
一、死鎖的產生條件
死鎖的發生通常需要滿足以下四個條件：
- 互斥條件：資源不能被多個線程同時使用。即某個資源在某個時刻只能被一個線程占有。
- 占有且等待條件：一個線程已經持有至少一個資源，并且在等待獲取額外的資源，而這些資源被其他線程持有。
- 不可剝奪條件：資源不能被強制剝奪，線程只能在完成任務后自愿釋放所持有的資源。
- 環路等待條件：存在一個線程等待鏈，鏈中的每個線程都在等待鏈中的下一個線程所持有的資源。
當上面這四個條件同時滿足時，就會發生死鎖。
二、死鎖的案例
如下圖：線程1持有 ResourceA的鎖并等待 ResourceB的鎖，線程2持有 ResourceB的鎖并等待ResourceA的鎖，這樣Thread1和Thread2就形成了死鎖。
下面，我們通過一個簡單的Java示例來描述上面死鎖的情況：
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(10); } catch (InterruptedException e) {}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) {
System.out.println("Thread 1: Holding lock 1 & 2...");
}
}
});
Thread thread2 = new Thread(() -> {
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...");
}
}
});
thread1.start();
thread2.start();
}
}在這個例子中，thread1首先獲得lock1，然后等待lock2，而thread2首先獲得lock2，然后等待lock1。這就導致了死鎖，因為兩個線程都在等待對方持有的鎖并且無法繼續執行。
三、避免死鎖的方法
在 Java中，避免的死鎖的方式還是比較豐富的，這里我列舉了一些常見的避免死鎖的方法：
1. 資源排序法
資源排序法（Resource Ordering）是通過對資源進行全局排序，確保所有線程都按照相同的順序獲取鎖，從而避免循環等待。例如，線程在獲取多個鎖時，總是先獲取編號小的鎖，再獲取編號大的鎖。
2. 嘗試鎖
嘗試鎖（Try Lock）是使用tryLock()方法來代替lock()方法。在嘗試獲取鎖時，設置一個超時時間，如果在規定時間內無法獲得鎖，則放棄獲取鎖，從而避免死鎖。
Lock lock1 = new ReentrantLock();
Lock lock2 = new ReentrantLock();
try {
if (lock1.tryLock(50, TimeUnit.MILLISECONDS)) {
try {
if (lock2.tryLock(50, TimeUnit.MILLISECONDS)) {
try {
// critical section
} finally {
lock2.unlock();
}
}
} finally {
lock1.unlock();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}3. 超時放棄法
超時放棄法（Timeout and Retry）是指為線程等待資源的時間設置上限，如果超過這個時間還沒有獲得資源，則主動放棄，并稍后重試。
如下示例展示了超時放棄法的實現：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
public class TimeoutAvoidanceExample {
private static final Lock lock1 = new ReentrantLock();
private static final Lock lock2 = new ReentrantLock();
public static void main(String[] args) {
Thread thread1 = new Thread(new Task(lock1, lock2), "Thread-1");
Thread thread2 = new Thread(new Task(lock2, lock1), "Thread-2");
thread1.start();
thread2.start();
}
static class Task implements Runnable {
private final Lock firstLock;
private final Lock secondLock;
public Task(Lock firstLock, Lock secondLock) {
this.firstLock = firstLock;
this.secondLock = secondLock;
}
@Override
public void run() {
while (true) {
try {
// 嘗試獲取第一個鎖
if (firstLock.tryLock(50, TimeUnit.MILLISECONDS)) {
try {
// 嘗試獲取第二個鎖
if (secondLock.tryLock(50, TimeUnit.MILLISECONDS)) {
try {
// 成功獲取兩個鎖后執行關鍵操作
System.out.println(Thread.currentThread().getName() + ": Acquired both locks, performing task.");
break; // 退出循環，任務完成
} finally {
secondLock.unlock();
}
}
} finally {
firstLock.unlock();
}
}
// 如果未能獲取鎖，則稍后重試
System.out.println(Thread.currentThread().getName() + ": Could not acquire both locks, retrying...");
Thread.sleep(10); // 等待一段時間后重試
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}代碼解讀：
- 鎖的定義：使用ReentrantLock來創建兩個鎖lock1和lock2。
- 線程任務：Task類實現了Runnable接口，每個任務嘗試以超時方式獲取兩個鎖。
- tryLock方法：tryLock(long time, TimeUnit unit)方法允許線程等待一段時間來獲取鎖，如果在指定時間內獲取不到鎖，則返回false。
- 循環重試：如果線程未能在超時內獲取到兩個鎖，它會釋放已經獲得的鎖，等待一段時間后再次嘗試。這種方式避免了死鎖，因為線程不會無限期地等待鎖。
- 線程啟動：創建并啟動兩個線程，每個線程嘗試獲取不同順序的鎖。
4. 死鎖檢測
在某些情況下，可以使用死鎖檢測算法來發現死鎖并采取措施。Java中的java.lang.management包提供了檢測死鎖的工具。
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
if (deadlockedThreads != null) {
System.out.println("Deadlock detected!");
// Handle the deadlock situation
}5. 減少鎖的持有時間
盡量縮短鎖的持有時間，確保在鎖內執行的操作盡可能少，從而減少發生死鎖的機會。
6. 使用更高層次的并發工具
Java提供了許多高級并發工具類，如java.util.concurrent包下的ConcurrentHashMap、Semaphore、CountDownLatch等，這些工具類在設計時就考慮了并發訪問的安全性并減少了死鎖的可能性。
7. 避免嵌套鎖
避免嵌套鎖（Avoid Nested Locks，盡量避免一個線程在持有一個鎖的同時去獲取另一個鎖，因為這會增加發生死鎖的風險。
四、總結
死鎖是多線程編程中一個復雜而又讓人頭疼的問題，在實際開發中，死鎖問題有時候發生還很難找到原因，因此，在日常開發中遵循良好的編程實踐，可以有效地避免和處理死鎖。
作為技術人員，需要掌握死鎖產生根本原因，這樣，即便死鎖發生了也能快速的定位和解決。
