[[420068]]

死鎖(Dead Lock)指的是兩個或兩個以上的運算單元(進(jìn)程、線程或協(xié)程)，都在等待對方停止執(zhí)行，以取得系統(tǒng)資源，但是沒有一方提前退出，就稱為死鎖。

死鎖示例代碼如下：

public class DeadLockExample { 
    public static void main(String[] args) { 
        Object lockA = new Object(); // 創(chuàng)建鎖 A 
        Object lockB = new Object(); // 創(chuàng)建鎖 B 
 
        // 創(chuàng)建線程 1 
        Thread t1 = new Thread(new Runnable() { 
            @Override 
            public void run() { 
                synchronized (lockA) { 
                    System.out.println("線程 1:獲取到鎖 A!"); 
                    try { 
                        Thread.sleep(1000); 
                    } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                    } 
                    System.out.println("線程 1:等待獲取 B..."); 
                    synchronized (lockB) { 
                        System.out.println("線程 1:獲取到鎖 B!"); 
                    } 
                } 
            } 
        }); 
        t1.start(); // 運行線程 
 
        // 創(chuàng)建線程 2 
        Thread t2 = new Thread(new Runnable() { 
            @Override 
            public void run() { 
                synchronized (lockB) { 
                    System.out.println("線程 2:獲取到鎖 B!"); 
                    try { 
                        Thread.sleep(1000); 
                    } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                    } 
                    System.out.println("線程 2:等待獲取 A..."); 
                    synchronized (lockA) { 
                        System.out.println("線程 2:獲取到鎖 A!"); 
                    } 
                } 
            } 
        }); 
        t2.start(); // 運行線程 
    } 
} 

以上程序的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，線程 1 和線程 2 都進(jìn)入了死鎖狀態(tài)，相互都在等待對方釋放鎖。

從上述示例分析可以得出，產(chǎn)生死鎖需要滿足以下 4 個條件：

1. 互斥條件：指運算單元(進(jìn)程、線程或協(xié)程)對所分配到的資源具有排它性，也就是說在一段時間內(nèi)某個鎖資源只能被一個運算單元所占用。
2. 請求和保持條件：指運算單元已經(jīng)保持至少一個資源，但又提出了新的資源請求，而該資源已被其它運算單元占有，此時請求運算單元阻塞，但又對自己已獲得的其它資源保持不放。
3. 不可剝奪條件：指運算單元已獲得的資源，在未使用完之前，不能被剝奪。
4. 環(huán)路等待條件：指在發(fā)生死鎖時，必然存在運算單元和資源的環(huán)形鏈，即運算單元正在等待另一個運算單元占用的資源，而對方又在等待自己占用的資源，從而造成環(huán)路等待的情況。

只有這 4 個條件同時滿足，才會造成死鎖的問題。

那么也就是說，要產(chǎn)生死鎖必須要同時滿足以上 4 個條件才行，那我們就可以通過破壞任意一個條件來解決死鎖問題了。

死鎖解決方案分析

接下來我們來分析一下，產(chǎn)生死鎖的 4 個條件，哪些是可以破壞的?哪些是不能被破壞的?

• 互斥條件：系統(tǒng)特性，不能被破壞。
• 請求和保持條件：可以被破壞。
• 不可剝奪條件：系統(tǒng)特性，不能被破壞。
• 環(huán)路等待條件：可以被破壞。

通過上述分析，我們可以得出結(jié)論，我們只能通過破壞請求和保持條件或者是環(huán)路等待條件，從而來解決死鎖的問題，那上線，我們就先從破壞“環(huán)路等待條件”開始來解決死鎖問題。

解決方案1：順序鎖

所謂的順序鎖指的是通過有順序的獲取鎖，從而避免產(chǎn)生環(huán)路等待條件，從而解決死鎖問題的。

當(dāng)我們沒有使用順序鎖時，程序的執(zhí)行可能是這樣的：

線程 1 先獲取了鎖 A，再獲取鎖 B，線程 2 與 線程 1 同時執(zhí)行，線程 2 先獲取鎖 B，再獲取鎖 A，這樣雙方都先占用了各自的資源(鎖 A 和鎖 B)之后，再嘗試獲取對方的鎖，從而造成了環(huán)路等待問題，最后造成了死鎖的問題。

此時我們只需要將線程 1 和線程 2 獲取鎖的順序進(jìn)行統(tǒng)一，也就是線程 1 和線程 2 同時執(zhí)行之后，都先獲取鎖 A，再獲取鎖 B，執(zhí)行流程如下圖所示：

因為只有一個線程能成功獲取到鎖 A，沒有獲取到鎖 A 的線程就會等待先獲取鎖 A，此時得到鎖 A 的線程繼續(xù)獲取鎖 B，因為沒有線程爭搶和擁有鎖 B，那么得到鎖 A 的線程就會順利的擁有鎖 B，之后執(zhí)行相應(yīng)的代碼再將鎖資源全部釋放，然后另一個等待獲取鎖 A 的線程就可以成功獲取到鎖資源，執(zhí)行后續(xù)的代碼，這樣就不會出現(xiàn)死鎖的問題了。

順序鎖的實現(xiàn)代碼如下所示：

public class SolveDeadLockExample { 
    public static void main(String[] args) { 
        Object lockA = new Object(); // 創(chuàng)建鎖 A 
        Object lockB = new Object(); // 創(chuàng)建鎖 B 
        // 創(chuàng)建線程 1 
        Thread t1 = new Thread(new Runnable() { 
            @Override 
            public void run() { 
                synchronized (lockA) { 
                    System.out.println("線程 1:獲取到鎖 A!"); 
                    try { 
                        Thread.sleep(1000); 
                    } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                    } 
                    System.out.println("線程 1:等待獲取 B..."); 
                    synchronized (lockB) { 
                        System.out.println("線程 1:獲取到鎖 B!"); 
                    } 
                } 
            } 
        }); 
        t1.start(); // 運行線程 
        // 創(chuàng)建線程 2 
        Thread t2 = new Thread(new Runnable() { 
            @Override 
            public void run() { 
                synchronized (lockA) { 
                    System.out.println("線程 2:獲取到鎖 A!"); 
                    try { 
                        Thread.sleep(1000); 
                    } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                    } 
                    System.out.println("線程 2:等待獲取B..."); 
                    synchronized (lockB) { 
                        System.out.println("線程 2:獲取到鎖 B!"); 
                    } 
                } 
            } 
        }); 
        t2.start(); // 運行線程 
    } 
} 

以上程序的執(zhí)行結(jié)果如下：

從上述執(zhí)行結(jié)果可以看出，程序并沒有出現(xiàn)死鎖的問題。

解決方案2：輪詢鎖

輪詢鎖是通過打破“請求和保持條件”來避免造成死鎖的，它的實現(xiàn)思路簡單來說就是通過輪詢來嘗試獲取鎖，如果有一個鎖獲取失敗，則釋放當(dāng)前線程擁有的所有鎖，等待下一輪再嘗試獲取鎖。

輪詢鎖的實現(xiàn)需要使用到 ReentrantLock 的 tryLock 方法，具體實現(xiàn)代碼如下：

import java.util.concurrent.locks.Lock; 
import java.util.concurrent.locks.ReentrantLock; 
 
public class SolveDeadLockExample { 
     
    public static void main(String[] args) { 
        Lock lockA = new ReentrantLock(); // 創(chuàng)建鎖 A 
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B 
 
        // 創(chuàng)建線程 1(使用輪詢鎖) 
        Thread t1 = new Thread(new Runnable() { 
            @Override 
            public void run() { 
                // 調(diào)用輪詢鎖 
                pollingLock(lockA, lockB); 
            } 
        }); 
        t1.start(); // 運行線程 
 
        // 創(chuàng)建線程 2 
        Thread t2 = new Thread(new Runnable() { 
            @Override 
            public void run() { 
                lockB.lock(); // 加鎖 
                System.out.println("線程 2:獲取到鎖 B!"); 
                try { 
                    Thread.sleep(1000); 
                    System.out.println("線程 2:等待獲取 A..."); 
                    lockA.lock(); // 加鎖 
                    try { 
                        System.out.println("線程 2:獲取到鎖 A!"); 
                    } finally { 
                        lockA.unlock(); // 釋放鎖 
                    } 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } finally { 
                    lockB.unlock(); // 釋放鎖 
                } 
            } 
        }); 
        t2.start(); // 運行線程 
    } 
     
     /** 
     * 輪詢鎖 
     */ 
    public static void pollingLock(Lock lockA, Lock lockB) { 
        while (true) { 
            if (lockA.tryLock()) { // 嘗試獲取鎖 
                System.out.println("線程 1:獲取到鎖 A!"); 
                try { 
                    Thread.sleep(1000); 
                    System.out.println("線程 1:等待獲取 B..."); 
                    if (lockB.tryLock()) { // 嘗試獲取鎖 
                        try { 
                            System.out.println("線程 1:獲取到鎖 B!"); 
                        } finally { 
                            lockB.unlock(); // 釋放鎖 
                            System.out.println("線程 1:釋放鎖 B."); 
                            break; 
                        } 
                    } 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } finally { 
                    lockA.unlock(); // 釋放鎖 
                    System.out.println("線程 1:釋放鎖 A."); 
                } 
            } 
            // 等待一秒再繼續(xù)執(zhí)行 
            try { 
                Thread.sleep(1000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
} 

以上程序的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，以上代碼也沒有出現(xiàn)死鎖的問題。

總結(jié)

本文介紹了解決死鎖的 2 種方案：

• 第 1 種順序鎖：通過改變獲取鎖的順序也就打破“環(huán)路請求條件”來避免死鎖問題的發(fā)生;
• 第 2 種輪詢鎖：通過輪詢的方式也就是打破“請求和擁有條件”來解決死鎖問題。它的實現(xiàn)思路是，通過自旋的方式來嘗試獲取鎖，在獲取鎖的途中，如果有任何一個鎖獲取失敗，則釋放之前獲取的所有鎖，等待一段時間之后再次執(zhí)行之前的流程，這樣就避免一個鎖一直被(一個線程)占用的尷尬了，從而避免了死鎖問題。

參考 & 鳴謝

《Java并發(fā)編程實戰(zhàn)》