死鎖（Dead Lock）指的是兩個或兩個以上的運算單元（進程、線程或協(xié)程），都在等待對方釋放資源，但沒有一方提前釋放資源，從而造成了一種阻塞的現(xiàn)象就稱為死鎖。
死鎖（Dead Lock）指的是兩個或兩個以上的運算單元（進程、線程或協(xié)程），都在等待對方釋放資源，但沒有一方提起釋放資源，從而造成了一種阻塞的現(xiàn)象就稱為死鎖。
比如線程 1 擁有了鎖 A 的情況下試圖獲取鎖 B，而線程 2 又在擁有了鎖 B 的情況下試圖獲取鎖 A，這樣雙方就進入相互阻塞等待的情況，如下圖所示：
死鎖的代碼實現(xiàn)如下：
import java.util.concurrent.TimeUnit;
public class DeadLockTest {
public static void main(String[] args) {
Object lockA = new Object();
Object lockB = new Object();
// 創(chuàng)建線程 1
Thread t1 = new Thread(() -> {
// 1.占有鎖 A
synchronized (lockA) {
System.out.println("線程1：獲得鎖A。");
// 休眠 1s（讓線程 2 有時間先占有鎖 B）
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 2.獲取線程 2 的鎖 B
synchronized (lockB) {
System.out.println("線程1：獲得鎖B。");
}
}
});
t1.start();
// 創(chuàng)建線程 2
Thread t2 = new Thread(() -> {
// 1.占有鎖 B
synchronized (lockB) {
System.out.println("線程2：獲得鎖B。");
// 休眠 1s（保證線程 1 能有充足的時間得到鎖 A）
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 2.獲取線程 1 的鎖 A
synchronized (lockA) {
System.out.println("線程2：獲得鎖A。");
}
}
});
t2.start();
}
}
以上程序的執(zhí)行結果如下圖所示：
從上述結果可以看出，線程 1 和線程 2 都在等待對方釋放鎖，這樣就造成了死鎖問題。
死鎖產(chǎn)生原因
死鎖的產(chǎn)生需要滿足以下 4 個條件：
- 互斥條件：指運算單元（進程、線程或協(xié)程）對所分配到的資源具有排它性，也就是說在一段時間內(nèi)某個鎖資源只能被一個運算單元所占用。
- 請求和保持條件：指運算單元已經(jīng)保持至少一個資源，但又提出了新的資源請求，而該資源已被其它運算單元占有，此時請求運算單元阻塞，但又對自己已獲得的其它資源保持不放。
- 不可剝奪條件：指運算單元已獲得的資源，在未使用完之前，不能被剝奪。
- 環(huán)路等待條件：指在發(fā)生死鎖時，必然存在運算單元和資源的環(huán)形鏈，即運算單元正在等待另一個運算單元占用的資源，而對方又在等待自己占用的資源，從而造成環(huán)路等待的情況。
只有以上 4 個條件同時滿足，才會造成死鎖。
解決死鎖
死鎖產(chǎn)生要滿足以上 4 個必要條件，那么我們只需要改變其中的 1 個或多個條件就可以解決死鎖的問題了，比如我們可以通過修改獲取鎖的順序來改變環(huán)路等待條件。
在未修改獲取鎖的順序前，程序的執(zhí)行流程是這樣的：
其中 ① 表示先執(zhí)行，② 表示后執(zhí)行。而改變鎖的獲取順序之后的執(zhí)行流程是這樣的：
此時線程 1 和線程 2 獲取鎖的順序是一致的，都是先獲取鎖 A，再獲取鎖 B，此時它們的執(zhí)行流程如下：
- 線程 1 先獲取到鎖 A；
- 線程 1 獲取到鎖 B；
- 線程 1 釋放了鎖 B；
- 線程 1 釋放了鎖 A；
- 線程 2 獲取到了鎖 A；
- 線程 2 獲取到了鎖 B；
- 線程 2 釋放了鎖 B；
- 線程 2 釋放了鎖 A。
對應的實現(xiàn)代碼如下：
import java.util.concurrent.TimeUnit;
class DeadLockTest {
public static void main(String[] args) {
Object lockA = new Object();
Object lockB = new Object();
// 創(chuàng)建線程 1
Thread t1 = new Thread(() -> {
// 1.獲取鎖 A
synchronized (lockA) {
System.out.println("線程1：獲得鎖A。");
// 休眠 1s
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 2.獲取鎖 B
synchronized (lockB) {
System.out.println("線程1：獲得鎖B。");
System.out.println("線程1：釋放鎖B。");
}
System.out.println("線程1：釋放鎖A。");
}
});
t1.start();
// 創(chuàng)建線程 2
Thread t2 = new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 1.獲取鎖 A
synchronized (lockA) {
System.out.println("線程2：獲得鎖A。");
// 2.獲取鎖
synchronized (lockB) {
System.out.println("線程2：獲得鎖B。");
System.out.println("線程2：釋放鎖B。");
}
System.out.println("線程2：釋放鎖A。");
}
});
t2.start();
}
}
以上程序的執(zhí)行結果如下圖所示：
總結
死鎖（Dead Lock）指的是兩個或兩個以上的運算單元（進程、線程或協(xié)程），都在等待對方釋放資源，但沒有一方提前釋放資源，從而造成了一種阻塞的現(xiàn)象就稱為死鎖。產(chǎn)生死鎖需要同時滿足 4 個條件：互斥條件、請求和保持條件、不可剝奪條件、環(huán)路等待條件，因此我們只需要破壞其中 1 個或多個條件就可以解決死鎖的問題了。
