Java死鎖問題解析

一、什麼是死鎖

死鎖是指兩個或以上的進程在互相請求資源的時候形成了僵局，導致它們等待對方釋放資源而無法繼續執行下去。在這種情況下，這些進程永遠阻塞並且等待資源。死鎖是一種非常常見的並發問題，在多線程編程中尤其需要注意。

二、死鎖的必要條件

死鎖的發生需要滿足以下四個必要條件：

1. 互斥條件：資源不能被共享，只能由一個進程佔用。
2. 請求與保持條件：一個進程已經得到了資源，但是還需要請求其他資源。
3. 非搶佔條件：進程不能強制從別的進程中獲取資源，只能通過自己釋放資源來讓其他進程獲取資源。
4. 循環等待條件：存在一個循環等待的進程鏈。

三、死鎖代碼示例

public class DeadLockDemo {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();
    
    public static void main(String[] args) {
        new Thread(() -> {
            synchronized(lock1) {
                System.out.println("Thread1 holds lock1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(lock2) {
                    System.out.println("Thread1 holds lock1 and lock2");
                }
            }
        }).start();
        
        new Thread(() -> {
            synchronized(lock2) {
                System.out.println("Thread2 holds lock2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(lock1) {
                    System.out.println("Thread2 holds lock1 and lock2");
                }
            }
        }).start();
    }
}

四、死鎖解決方法

避免和解決死鎖問題有以下幾種方法：

1. 避免循環等待
2. 破壞互斥條件
3. 採用超時機制等待資源的釋放
4. 資源一致性管理
5. 使用鎖的層次結構來避免死鎖

五、使用鎖的層次結構避免死鎖

public class LockHierarchyDemo {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();
    
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized(lock1) {
                System.out.println("Thread1 holds lock1");
                synchronized(lock2) {
                    System.out.println("Thread1 holds lock1 and lock2");
                }
            }
        });
        
        Thread thread2 = new Thread(() -> {
            synchronized(lock1) {
                System.out.println("Thread2 holds lock1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(lock2) {
                    System.out.println("Thread2 holds lock1 and lock2");
                }
            }
        });
        
        thread1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }
}

這個示例中，兩個線程請求鎖的順序一致，不會發生循環依賴的情況。如果一個線程請求了多個鎖，並在請求鎖的時候等待時間超過了閾值，該線程釋放所有的鎖，等待一段時間後再次請求鎖。這種方式可以減小死鎖的概率。