Java 死鎖解決方案順序鎖和輪詢鎖
前言:
死鎖(Dead Lock)指的是兩個或兩個以上的運算單元(進程、線程或協程),都在等待對方停止執行,以取得系統資源,但是沒有一方提前退出,就稱為死鎖。
死鎖示例代碼如下:
public class DeadLockExample { public static void main(String[] args) { Object lockA = new Object(); // 創建鎖 A Object lockB = new Object(); // 創建鎖 B // 創建線程 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(); // 運行線程 // 創建線程 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(); // 運行線程 } }
以上程序的執行結果如下:
從上述結果可以看出,線程 1 和線程 2 都進入瞭死鎖狀態,相互都在等待對方釋放鎖。
從上述示例分析可以得出,產生死鎖需要滿足以下 4 個條件:
- 互斥條件:指運算單元(進程、線程或協程)對所分配到的資源具有排它性,也就是說在一段時間內某個鎖資源隻能被一個運算單元所占用。
- 請求和保持條件:指運算單元已經保持至少一個資源,但又提出瞭新的資源請求,而該資源已被其它運算單元占有,此時請求運算單元阻塞,但又對自己已獲得的其它資源保持不放。
- 不可剝奪條件:指運算單元已獲得的資源,在未使用完之前,不能被剝奪。
- 環路等待條件:指在發生死鎖時,必然存在運算單元和資源的環形鏈,即運算單元正在等待另一個運算單元占用的資源,而對方又在等待自己占用的資源,從而造成環路等待的情況。
隻有這 4 個條件同時滿足,才會造成死鎖的問題。
那麼也就是說,要產生死鎖必須要同時滿足以上 4 個條件才行,那我們就可以通過破壞任意一個條件來解決死鎖問題瞭。
死鎖解決方案分析
接下來我們來分析一下,產生死鎖的 4 個條件,哪些是可以破壞的?哪些是不能被破壞的?
- 互斥條件:系統特性,不能被破壞。
- 請求和保持條件:可以被破壞。
- 不可剝奪條件:系統特性,不能被破壞。
- 環路等待條件:可以被破壞。
通過上述分析,我們可以得出結論,我們隻能通過破壞請求和保持條件或者是環路等待條件,從而來解決死鎖的問題,那上線,我們就先從破壞“環路等待條件”開始來解決死鎖問題。
解決方案1:順序鎖
所謂的順序鎖指的是通過有順序的獲取鎖,從而避免產生環路等待條件,從而解決死鎖問題的。
當我們沒有使用順序鎖時,程序的執行可能是這樣的:
線程 1 先獲取瞭鎖 A,再獲取鎖 B,線程 2 與 線程 1 同時執行,線程 2 先獲取鎖 B,再獲取鎖 A,這樣雙方都先占用瞭各自的資源(鎖 A 和鎖 B)之後,再嘗試獲取對方的鎖,從而造成瞭環路等待問題,最後造成瞭死鎖的問題。
此時我們隻需要將線程 1 和線程 2 獲取鎖的順序進行統一,也就是線程 1 和線程 2 同時執行之後,都先獲取鎖 A,再獲取鎖 B,執行流程如下圖所示:
因為隻有一個線程能成功獲取到鎖 A,沒有獲取到鎖 A 的線程就會等待先獲取鎖 A,此時得到鎖 A 的線程繼續獲取鎖 B,因為沒有線程爭搶和擁有鎖 B,那麼得到鎖 A 的線程就會順利的擁有鎖 B,之後執行相應的代碼再將鎖資源全部釋放,然後另一個等待獲取鎖 A 的線程就可以成功獲取到鎖資源,執行後續的代碼,這樣就不會出現死鎖的問題瞭。
順序鎖的實現代碼如下所示:
public class SolveDeadLockExample { public static void main(String[] args) { Object lockA = new Object(); // 創建鎖 A Object lockB = new Object(); // 創建鎖 B // 創建線程 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(); // 運行線程 // 創建線程 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(); // 運行線程 } }
以上程序的執行結果如下:
從上述執行結果可以看出,程序並沒有出現死鎖的問題。
解決方案2:輪詢鎖
輪詢鎖是通過打破“請求和保持條件”來避免造成死鎖的,它的實現思路簡單來說就是通過輪詢來嘗試獲取鎖,如果有一個鎖獲取失敗,則釋放當前線程擁有的所有鎖,等待下一輪再嘗試獲取鎖。
輪詢鎖的實現需要使用到 ReentrantLock 的 tryLock 方法,具體實現代碼如下:
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(); // 創建鎖 A Lock lockB = new ReentrantLock(); // 創建鎖 B // 創建線程 1(使用輪詢鎖) Thread t1 = new Thread(new Runnable() { @Override public void run() { // 調用輪詢鎖 pollingLock(lockA, lockB); } }); t1.start(); // 運行線程 // 創建線程 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."); } } // 等待一秒再繼續執行 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
以上程序的執行結果如下:
從上述結果可以看出,以上代碼也沒有出現死鎖的問題。
總結
本文介紹瞭解決死鎖的 2 種方案:
- 第 1 種順序鎖:通過改變獲取鎖的順序也就打破“環路請求條件”來避免死鎖問題的發生;
- 第 2 種輪詢鎖:通過輪詢的方式也就是打破“請求和擁有條件”來解決死鎖問題。它的實現思路是,通過自旋的方式來嘗試獲取鎖,在獲取鎖的途中,如果有任何一個鎖獲取失敗,則釋放之前獲取的所有鎖,等待一段時間之後再次執行之前的流程,這樣就避免一個鎖一直(被一個線程)占用的尷尬瞭,從而避免瞭死鎖問題。
到此這篇關於Java 死鎖終解決方案順序鎖和輪詢鎖的文章就介紹到這瞭,更多相關Java 死鎖方案內容請搜索LevelAH以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持LevelAH!