java安全編碼指南之:死鎖dead lock
阿新 • • 發佈：2020-10-01
[toc]
# 簡介
java中為了保證共享資料的安全性，我們引入了鎖的機制。有了鎖就有可能產生死鎖。
死鎖的原因就是多個執行緒鎖住了對方所需要的資源，然後現有的資源又沒有釋放，從而導致迴圈等待的情況。
通常來說如果不同的執行緒對加鎖和釋放鎖的順序不一致的話，就很有可能產生死鎖。
# 不同的加鎖順序
我們來看一個不同加鎖順序的例子：
~~~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的順序是可以傳送變化的：
~~~java
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就夠了：
~~~java
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欄位：
~~~java
private final long id; // 唯一ID，用來排序
private static final AtomicLong nextID = new AtomicLong(0); // 用來生成ID
public DiffLockWithOrder(int amount){
this.amount=amount;
this.id = nextID.getAndIncrement();
}
~~~
在初始化物件的時候，我們使用static的AtomicLong類來為每個物件生成唯一的ID。
在做transfer的時候，我們先比較兩個物件的ID大小，然後根據ID進行排序，最後安裝順序進行加鎖。這樣就能夠保證順序，從而避免死鎖。
~~~java
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來完成這個例子：
~~~java
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迴圈中，如果不能獲取到鎖就迴圈遍歷。
本文的程式碼：
[learn-java-base-9-to-20/tree/master/security](https://github.com/ddean2009/learn-java-base-9-to-20/tree/master/security)
>