【併發技術04】執行緒技術之死鎖問題

我們知道，使用 synchronized 關鍵字可以有效的解決執行緒同步問題，但是如果不恰當的使用 synchronized 關鍵字的話也會出問題，即我們所說的死鎖。死鎖是這樣一種情形：多個執行緒同時被阻塞，它們中的一個或者全部都在等待某個資源被釋放。由於執行緒被無限期地阻塞，因此程式不可能正常終止。

我們先寫一個死鎖的例子，再來分析一下死鎖產生的原因：

public class DeadLock {
    public static void main(String[] args) {
        Business business = new Business1();
        //開啟一個執行緒執行Business類中的functionA方法
        new Thread(new Runnable() {         
            @Override
            public void run() {
                while(true) {
                    business.functionA();
                }
            }
        }).start();
        //開啟另一個執行緒執行Business類中的functionB方法
        new Thread(new Runnable() {         
            @Override
            public void run() {
                while(true) {
                    business.functionB();
                }
            }
        }).start();
    }
}
class Business { //定義兩個鎖，兩個方法
    //定義兩個鎖
    public static final Object lock_a = new Object();
    public static final Object lock_b = new Object();   
    public void functionA() {
        synchronized(lock_a) {
            System.out.println("---ThreadA---lock_a---");
            synchronized(lock_b) {
                System.out.println("---ThreadA---lock_b---");
            }
        }
    }
    public void functionB() {
        synchronized(lock_b) {
            System.out.println("---ThreadB---lock_b---");
            synchronized(lock_a) {
                System.out.println("---ThreadB---lock_a---");
            }
        }
    }
}

程式的結構很清晰，沒什麼難度，先看一下程式的執行結果：

---ThreadA---lock a---
---ThreadA---lock b---
---ThreadA---lock a---
---ThreadA---lock b---
---ThreadA---lock a---
---ThreadA---lock b---
---ThreadA---lock a---
---ThreadB---lock b---

從執行結果來看，執行緒 A 跑著跑著，當執行緒 B 一跑，啪嘰一下就掛了。我們來分析一下原因：從上面的程式碼中可以看出，定義了一個類 Business，該類中維護了兩個鎖和兩個方法，每個方法都是 synchronized 連環套，並且使用的是不同的鎖。好了，現在  main  方法中開啟兩個執行緒 A 和 B，分別執行 Business 類中的兩個方法。A 優先執行，跑的很爽，當 B 執行緒也開始執行的時候，問題來了，從執行結果的最後兩行來看，A 執行緒進入了  functionA 方法中的第一個 synchronized，拿到了  lock_a  鎖，B 執行緒進入了  functionB  中的第一個 synchronized，拿到了  lock_b  鎖，並且兩者的鎖都還沒釋放。接下來就是關鍵了：A 執行緒進入第二個 synchronized 的時候，發現  lock_b  正在被 B 佔用，那沒辦法，它只好被阻塞，等唄~同樣地，B 執行緒進入第二個 synchronized 的時候，發現  lock_a  正在被 A 佔用，那沒辦法，它也只好被阻塞，等唄~好了，兩個就這樣互相等著，你不放，我也不放……死了……

上面這個程式對於理解死鎖很有幫助，因為結構很好，不過個人感覺這個死的還不過癮，因為兩個執行緒是實現了兩個不同的 Runnable 介面，只不過呼叫了同一個類的兩個方法而已，因為我把要同步的方法放到一個類中了。下面我把程式改一下，把要同步的程式碼放到一個 Runnable 中，讓它一執行就掛掉……

public class DeadLock {    
    public static void main(String[] args) {            
        //開啟兩個執行緒，分別扔兩個自定義的Runnable進去
        new Thread(new MyRunnable(true)).start();;
        new Thread(new MyRunnable(false)).start();;
    }
}
class MyRunnable implements Runnable
{
    private boolean flag; //用於判斷，執行不同的同步程式碼塊 
    MyRunnable(boolean flag) { //構造方法
        this.flag = flag;
    }
    @Override
    public void run()
    {
        if(flag)
        {
            while(true){            
                synchronized(MyLock.lock_a)
                {
                    System.out.println("--threadA---lock_a--");
                    synchronized(MyLock.lock_b)
                    {
                        System.out.println("--threadA---lock_b--");
                    }   
                }
            }
        }
        else
        {
            while(true){            
                synchronized(MyLock.lock_b)
                {
                    System.out.println("--threadB---lock_a--");
                    synchronized(MyLock.lock_a)
                    {
                        System.out.println("--threadB---lock_b--");
                    }   
                }
            }
        }
    }
}
class MyLock //把兩把鎖放到一個類中定義，是為了兩個執行緒使用的都是這兩把鎖
{
    public static final Object lock_a = new Object();
    public static final Object lock_b = new Object();   
}

這個死鎖就厲害了，一執行，啪嘰一下直接就掛掉了……看下執行結果：

--threadA---lock a--
--threadB---lock b--

以上是死鎖的兩個例子，都比較容易理解和記憶，主要是 “設計模式” 不太一樣，第一種結構更加清晰，主函式中只要執行邏輯即可，關於同步的部分全扔到 Business 中，這個便於後期維護，我隨便把 Business 扔到哪去執行都行，因為所有同步的東西都在它自己的類中，這種設計思想很好。第二種是把 Runnable 先定義好，透過構造方法傳進來不同的 boolean 型別值決定執行  run ()  方法中不同的部分，這種思路也很容易理解，這種死鎖更厲害，兩個執行緒直接執行相反的部分，直接掛掉，不給對方一點情面~

如果覺得對您有幫助，轉發給更多人吧