Java 中什么情況會導致死鎖？如何避免？
在 Java編程中，死鎖是一種常見的多線程問題，它發(fā)生在兩個或多個線程彼此等待對方持有的資源時，導致這些線程都無法繼續(xù)執(zhí)行。死鎖問題的解決和避免是多線程編程中的一個重要課題。這篇文章，我們一起來探討 Java中死鎖的情況及避免方法的詳細。
一、死鎖的產(chǎn)生條件
死鎖的發(fā)生通常需要滿足以下四個條件：
- 互斥條件：資源不能被多個線程同時使用。即某個資源在某個時刻只能被一個線程占有。
- 占有且等待條件：一個線程已經(jīng)持有至少一個資源，并且在等待獲取額外的資源，而這些資源被其他線程持有。
- 不可剝奪條件：資源不能被強制剝奪，線程只能在完成任務后自愿釋放所持有的資源。
- 環(huán)路等待條件：存在一個線程等待鏈，鏈中的每個線程都在等待鏈中的下一個線程所持有的資源。
當上面這四個條件同時滿足時，就會發(fā)生死鎖。
二、死鎖的案例
如下圖：線程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。這就導致了死鎖，因為兩個線程都在等待對方持有的鎖并且無法繼續(xù)執(zhí)行。
三、避免死鎖的方法
在 Java中，避免的死鎖的方式還是比較豐富的，這里我列舉了一些常見的避免死鎖的方法：
1. 資源排序法
資源排序法（Resource Ordering）是通過對資源進行全局排序，確保所有線程都按照相同的順序獲取鎖，從而避免循環(huán)等待。例如，線程在獲取多個鎖時，總是先獲取編號小的鎖，再獲取編號大的鎖。
2. 嘗試鎖
嘗試鎖（Try Lock）是使用tryLock()方法來代替lock()方法。在嘗試獲取鎖時，設置一個超時時間，如果在規(guī)定時間內(nèi)無法獲得鎖，則放棄獲取鎖，從而避免死鎖。
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）是指為線程等待資源的時間設置上限，如果超過這個時間還沒有獲得資源，則主動放棄，并稍后重試。
如下示例展示了超時放棄法的實現(xiàn)：
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 {
// 成功獲取兩個鎖后執(zhí)行關鍵操作
System.out.println(Thread.currentThread().getName() + ": Acquired both locks, performing task.");
break; // 退出循環(huán)，任務完成
} 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來創(chuàng)建兩個鎖lock1和lock2。
- 線程任務：Task類實現(xiàn)了Runnable接口，每個任務嘗試以超時方式獲取兩個鎖。
- tryLock方法：tryLock(long time, TimeUnit unit)方法允許線程等待一段時間來獲取鎖，如果在指定時間內(nèi)獲取不到鎖，則返回false。
- 循環(huán)重試：如果線程未能在超時內(nèi)獲取到兩個鎖，它會釋放已經(jīng)獲得的鎖，等待一段時間后再次嘗試。這種方式避免了死鎖，因為線程不會無限期地等待鎖。
- 線程啟動：創(chuàng)建并啟動兩個線程，每個線程嘗試獲取不同順序的鎖。
4. 死鎖檢測
在某些情況下，可以使用死鎖檢測算法來發(fā)現(xiàn)死鎖并采取措施。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. 減少鎖的持有時間
盡量縮短鎖的持有時間，確保在鎖內(nèi)執(zhí)行的操作盡可能少，從而減少發(fā)生死鎖的機會。
6. 使用更高層次的并發(fā)工具
Java提供了許多高級并發(fā)工具類，如java.util.concurrent包下的ConcurrentHashMap、Semaphore、CountDownLatch等，這些工具類在設計時就考慮了并發(fā)訪問的安全性并減少了死鎖的可能性。
7. 避免嵌套鎖
避免嵌套鎖（Avoid Nested Locks，盡量避免一個線程在持有一個鎖的同時去獲取另一個鎖，因為這會增加發(fā)生死鎖的風險。
四、總結
死鎖是多線程編程中一個復雜而又讓人頭疼的問題，在實際開發(fā)中，死鎖問題有時候發(fā)生還很難找到原因，因此，在日常開發(fā)中遵循良好的編程實踐，可以有效地避免和處理死鎖。
作為技術人員，需要掌握死鎖產(chǎn)生根本原因，這樣，即便死鎖發(fā)生了也能快速的定位和解決。
