共計 3303 個字符，預計需要花費 9 分鐘才能閱讀完成。

java 中死鎖 dead lock 的示例分析，針對這個問題，這篇文章詳細介紹了相對應的分析和解答，希望可以幫助更多想解決這個問題的小伙伴找到更簡單易行的方法。

簡介

java 中為了保證共享數據的安全性，我們引入了鎖的機制。有了鎖就有可能產生死鎖。

死鎖的原因就是多個線程鎖住了對方所需要的資源，然后現有的資源又沒有釋放，從而導致循環等待的情況。

通常來說如果不同的線程對加鎖和釋放鎖的順序不一致的話，就很有可能產生死鎖。

不同的加鎖順序

我們來看一個不同加鎖順序的例子：

public class DiffLockOrder {private int amount;public DiffLockOrder(int amount){ this.amount=amount;
 }public void transfer(DiffLockOrder target,int transferAmount){synchronized (this){synchronized (target){if(amount  transferAmount){
 System.out.println( 余額不足！ }else{
 amount=amount-transferAmount;
 target.amount=target.amount+transferAmount;
 }
 }
 }
 }
}

上面的例子中，我們模擬一個轉賬的過程，amount 用來表示用戶余額。transfer 用來將當前賬號的一部分金額轉移到目標對象中。

為了保證在 transfer 的過程中，兩個賬戶不被別人修改，我們使用了兩個 synchronized 關鍵字，分別把 transfer 對象和目標對象進行鎖定。

看起來好像沒問題，但是我們沒有考慮在調用的過程中，transfer 的順序是可以發送變化的：

 DiffLockOrder account1 = new DiffLockOrder(1000);
 DiffLockOrder account2 = new DiffLockOrder(500);
 Runnable target1= ()- account1.transfer(account2,200);
 Runnable target2= ()- account2.transfer(account1,100);new Thread(target1).start();new Thread(target2).start();

上面的例子中，我們定義了兩個 account，然后兩個賬戶互相轉賬，最后很有可能導致互相鎖定，最后產生死鎖。

使用 private 類變量

使用兩個 sync 會有順序的問題，那么有沒有辦法只是用一個 sync 就可以在所有的實例中同步呢？

有的，我們可以使用 private 的類變量，因為類變量是在所有實例中共享的，這樣一次 sync 就夠了：

public class LockWithPrivateStatic {private int amount;private static final Object lock = new Object();public LockWithPrivateStatic(int amount){ this.amount=amount;
 }public void transfer(LockWithPrivateStatic target, int transferAmount){synchronized (lock) {if (amount   transferAmount) {
 System.out.println( 余額不足！ } else {
 amount = amount - transferAmount;
 target.amount = target.amount + transferAmount;
 }
 }
 }
}

使用相同的 Order

我們產生死鎖的原因是無法控制上鎖的順序，如果我們能夠控制上鎖的順序，是不是就不會產生死鎖了呢？

帶著這個思路，我們給對象再加上一個 id 字段：

 private final long id; //  唯一 ID，用來排序 private static final AtomicLong nextID = new AtomicLong(0); //  用來生成 IDpublic DiffLockWithOrder(int amount){ this.amount=amount;this.id = nextID.getAndIncrement();
 }

在初始化對象的時候，我們使用 static 的 AtomicLong 類來為每個對象生成唯一的 ID。

在做 transfer 的時候，我們先比較兩個對象的 ID 大小，然后根據 ID 進行排序，最后安裝順序進行加鎖。這樣就能夠保證順序，從而避免死鎖。

 public void transfer(DiffLockWithOrder target, int transferAmount){ DiffLockWithOrder fist, second;if (compareTo(target)   0) {
 fist = this;
 second = target;
 } else {
 fist = target;
 second = this;
 }synchronized (fist){synchronized (second){if(amount  transferAmount){
 System.out.println( 余額不足！ }else{
 amount=amount-transferAmount;
 target.amount=target.amount+transferAmount;
 }
 }
 }
 }

釋放掉已占有的鎖

死鎖是互相請求對方占用的鎖，但是對方的鎖一直沒有釋放，我們考慮一下，如果獲取不到鎖的時候，自動釋放已占用的鎖是不是也可以解決死鎖的問題呢？

因為 ReentrantLock 有一個 tryLock() 方法，我們可以使用這個方法來判斷是否能夠獲取到鎖，獲取不到就釋放已占有的鎖。

我們使用 ReentrantLock 來完成這個例子：

public class DiffLockWithReentrantLock {private int amount;private final Lock lock = new ReentrantLock();public DiffLockWithReentrantLock(int amount){this.amount=amount;
 }private void transfer(DiffLockWithReentrantLock target, int transferAmount)throws InterruptedException {while (true) {if (this.lock.tryLock()) {try {if (target.lock.tryLock()) {try {if(amount  transferAmount){
 System.out.println( 余額不足！ }else{
 amount=amount-transferAmount;
 target.amount=target.amount+transferAmount;
 }break;
 } finally { target.lock.unlock();
 }
 }
 } finally {this.lock.unlock();
 }
 }// 隨機 sleep 一定的時間，保證可以釋放掉鎖 Thread.sleep(1000+new Random(1000L).nextInt(1000));
 }
 }
}

我們把兩個 tryLock 方法在 while 循環中，如果不能獲取到鎖就循環遍歷。

關于 java 中死鎖 dead lock 的示例分析問題的解答就分享到這里了，希望以上內容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關注丸趣 TV 行業資訊頻道了解更多相關知識。