java安全編碼指南之:死鎖dead lock

flydean發表於2020-10-01

簡介

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); // 用來生成ID

    public 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迴圈中,如果不能獲取到鎖就迴圈遍歷。

本文的程式碼:

learn-java-base-9-to-20/tree/master/security

本文已收錄於 http://www.flydean.com/java-security-code-line-dead-lock/

最通俗的解讀,最深刻的乾貨,最簡潔的教程,眾多你不知道的小技巧等你來發現!

歡迎關注我的公眾號:「程式那些事」,懂技術,更懂你!

相關文章