前兩天看極客時間 Java 併發課程的時候，刷到一個概念：活鎖。死鎖，倒是不陌生，活鎖卻是第一次聽到。

在介紹活鎖之前,我們先來複習一下死鎖，下面的例子模擬一個轉賬業務，多執行緒環境，為了賬戶金額安全，對賬戶進行了加鎖。

public class Account {
    public Account(int balance, String card) {
        this.balance = balance;
        this.card = card;
    }
    private int balance;
    private String card;
    public void addMoney(int amount) {
        balance += amount;
    }
    // 省略 get set 方法
}
public class AccountDeadLock {
    public static void transfer(Account from, Account to, int amount) throws InterruptedException {
        // 模擬正常的前置業務
        TimeUnit.SECONDS.sleep(1);
        synchronized (from) {
            System.out.println(Thread.currentThread().getName() + " lock from account " + from.getCard());
            synchronized (to) {
                System.out.println(Thread.currentThread().getName() + " lock to account " + to.getCard());
                // 轉出賬號扣錢
                from.addMoney(-amount);
                // 轉入賬號加錢
                to.addMoney(amount);
            }
        }
        System.out.println("transfer success");
    }

    public static void main(String[] args) {
        Account from = new Account(100, "6000001");
        Account to = new Account(100, "6000002");

        ExecutorService threadPool = Executors.newFixedThreadPool(2);

        // 執行緒 1
        threadPool.execute(() -> {
            try {
                transfer(from, to, 50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 執行緒 2
        threadPool.execute(() -> {
            try {
                transfer(to, from, 30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });


    }
}
 

上述例子中，當兩個執行緒進入轉賬方法，執行緒 1 獲取賬戶 6000001 這把鎖，執行緒 2 鎖住了賬戶 6000002 鎖。

接著當執行緒 1 想去獲取 6000002 的鎖時，由於這把鎖已經被執行緒 2 持有，執行緒 1 將會陷入阻塞，執行緒狀態轉為 BLOCKED。同理，執行緒 2 也是同樣狀態。

pool-1-thread-1 lock from account 6000001
pool-1-thread-2 lock from account 6000002

通過日誌，可以看到兩個執行緒開始轉賬方法之後，就陷入等待。

synchronized 獲取不到鎖就會阻塞，進行等待。既然這樣，我們可以使用 ReentrantLock#tryLock(long timeout, TimeUnit unit)

進行改造。tryLock 若能獲取鎖，將會返回 true，若不能獲取鎖將會進行等待，直到滿足下列條件：

• 超時時間內獲取到了鎖，返回 true
• 超時時間內未獲取到鎖，返回 false
• 中斷，丟擲異常

改造後代碼如下：

public class Account {
    public Account(int balance, String card) {
        this.balance = balance;
        this.card = card;
    }
    private int balance;
    private String card;
    public void addMoney(int amount) {
        balance += amount;
    }
    // 省略 get set 方法
}
public class AccountLiveLock {

    public static void transfer(Account from, Account to, int amount) throws InterruptedException {
        // 模擬正常的前置業務
        TimeUnit.SECONDS.sleep(1);
        // 保證轉賬一定成功
        while (true) {
            if (from.lock.tryLock(1, TimeUnit.SECONDS)) {
                try {
                    System.out.println(Thread.currentThread().getName() + " lock from account " + from.getCard());
                    if (to.lock.tryLock(1, TimeUnit.SECONDS)) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " lock to account " + to.getCard());
                            // 轉出賬號扣錢
                            from.addMoney(-amount);
                            // 轉入賬號加錢
                            to.addMoney(amount);
                            break;
                        } finally {
                            to.lock.unlock();
                        }

                    }
                } finally {
                    from.lock.unlock();
                }
            }
        }
        System.out.println("transfer success");

    }

    public static void main(String[] args) {
        Account from = new Account(100, "A");
        Account to = new Account(100, "B");

        ExecutorService threadPool = Executors.newFixedThreadPool(2);

        // 執行緒 1
        threadPool.execute(() -> {
            try {
                transfer(from, to, 50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 執行緒 2
        threadPool.execute(() -> {
            try {
                transfer(to, from, 30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }
}
 

上面程式碼使用了 while(true)，獲取鎖失敗，不斷重試，直到成功。執行這個方法，運氣好點，一把就能成功，運氣不好，就會如下：

pool-1-thread-1 lock from account 6000001
pool-1-thread-2 lock from account 6000002
pool-1-thread-2 lock from account 6000002
pool-1-thread-1 lock from account 6000001
pool-1-thread-1 lock from account 6000001
pool-1-thread-2 lock from account 6000002

transfer 方法一直在執行，但是最終卻得不到成功結果，這就是個活鎖的例子。

死鎖將會造成執行緒阻塞，程式看起來就像陷入假死一樣。就像路上碰到人，你盯著我，我盯著你，互相等待對方讓道，最後誰也過不去。

而活鎖不一樣，執行緒不斷重複同樣的操作，但也卻執行不成功。還拿上面舉例，這次你往左一步，他往右邊一步，巧了，又碰上。然後不斷迴圈，最會還是誰也過不去。

分析死鎖這個例子，兩個執行緒獲取的鎖的順序不一致，最後導致互相需要對方手中的鎖。如果兩個執行緒加鎖順序一致，所需條件就會一樣，勢必就不會產生死鎖了。

我們以卡號大小為順序，每次都給卡號比較大的賬戶先加鎖，這樣就可以解決死鎖問題，程式碼修改如下：

// 其他程式碼不變    
public static void transfer(Account from, Account to, int amount) throws InterruptedException {
        // 模擬正常的前置業務
        TimeUnit.SECONDS.sleep(1);
        Account maxAccount=from;
        Account minAccount=to;
        if(Long.parseLong(from.getCard())<Long.parseLong(to.getCard())){
            maxAccount=to;
            minAccount=from;
        }

        synchronized (maxAccount) {
            System.out.println(Thread.currentThread().getName() + " lock  account " + maxAccount.getCard());
            synchronized (minAccount) {
                System.out.println(Thread.currentThread().getName() + " lock  account " + minAccount.getCard());
                // 轉出賬號扣錢
                from.addMoney(-amount);
                // 轉入賬號加錢
                to.addMoney(amount);
            }
        }
        System.out.println("transfer success");
    }

對於活鎖的例子，存在兩個問題：

一是鎖的鎖超時時間都一樣，導致兩個執行緒幾乎同時釋放鎖，重試時又同時上鎖，然後陷入死迴圈。解決這個問題，我們可以使超時時間不一樣，引入一定的隨機性。

二是這裡使用 while(true),實際開發中萬萬不能這麼玩。這種情況我們需要設定最大的重試次數。

畫外音：如果重試這麼多次，一直不成功，但是業務卻想成功。現在不成功，不要傻著一直試，先放下，記錄下來，待會再重試補償唄~

活鎖的程式碼可以改成如下：

        public static final int MAX_TIME = 5;
    public static void transfer(Account from, Account to, int amount) throws InterruptedException {
        // 模擬正常的前置業務
        TimeUnit.SECONDS.sleep(1);
        // 保證轉賬一定成功
        Random random = new Random();
        int retryTimes = 0;
        boolean flag=false;
        while (retryTimes++ < MAX_TIME) {
            // 等待時間隨機
            if (from.lock.tryLock(random.nextInt(1000), TimeUnit.MILLISECONDS)) {
                try {
                    System.out.println(Thread.currentThread().getName() + " lock from account " + from.getCard());
                    if (to.lock.tryLock(random.nextInt(1000), TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " lock to account " + to.getCard());
                            // 轉出賬號扣錢
                            from.addMoney(-amount);
                            // 轉入賬號加錢
                            to.addMoney(amount);
                            flag=true;
                            break;
                        } finally {
                            to.lock.unlock();
                        }

                    }
                } finally {
                    from.lock.unlock();
                }
            }
        }
        if(flag){
            System.out.println("transfer success"); 
        }else {
            System.out.println("transfer failed");
        }
    }

總結

死鎖是日常開發中比較容易碰到的情況，我們需要小心，注意加鎖的順序。活鎖，碰到情況可能不常見，本質上我們只需要注意設定最大的重試次數，就不會永遠陷入一直重試中。

參考連結

http://c.biancheng.net/view/4786.html

https://www.javazhiyin.com/43117.html

歡迎關注我的公眾號：程式通事，獲得日常乾貨推送。如果您對我的專題內容感興趣，也可以關注我的部落格：studyidea.cn

相關推薦