Java多線程中的死鎖詳解

更新時間：2023年08月26日 08:29:48 作者：一只愛打拳的程序猿

這篇文章主要介紹了Java多線程中的死鎖詳解,死鎖是指兩個或多個線程在執(zhí)行過程中,因爭奪資源而造成的一種互相等待的現(xiàn)象,如果不提前預(yù)防或外界干擾,這些線程將無法執(zhí)行下去,需要的朋友可以參考下

前言

死鎖（Deadlock）是指兩個或多個線程在執(zhí)行過程中，因爭奪資源而造成的一種互相等待的現(xiàn)象

如果不提前預(yù)防或外界干擾，這些線程將無法執(zhí)行下去。

因此，本篇博文講解造成死鎖的原因以及解決方案。

1. 造成死鎖的原因

死鎖是多個線程在相互等待對方所占有的鎖才能繼續(xù)執(zhí)行下去，造成線程都被阻塞都無法執(zhí)行下去，也釋放不了線程自己的鎖資源，造成僵局。

舉例說明：

我和朋友去拉面館吃面，我先拿起了辣椒他拿起了醋。此時他想要辣椒、我想要醋，但我倆誰也不讓誰。

我對他說：你先把辣椒給我，我用完了就把醋給你。他對我說：你先把醋給我，我用完了就把辣椒給你。

我和他也不讓誰，最后導(dǎo)致死鎖。在上述例子中，辣椒和醋就是兩個鎖，我和他就是兩個線程。關(guān)于死鎖會引申的一個哲學(xué)家就餐問題。

2. 哲學(xué)家就餐問題

哲學(xué)家就餐問題是一個經(jīng)典的并發(fā)編程問題，它描述的是五個哲學(xué)家圍坐在一張圓形餐桌旁，每個哲學(xué)家面前有一碗飯和一只筷子，碗和筷子都是共享資源。

哲學(xué)家需要用一雙筷子來吃飯，但是只有相鄰的兩個哲學(xué)家之間有一只筷子，因此他們必須在餐桌上競爭筷子，才能拿到一雙筷子吃飯。

這個問題會引發(fā)死鎖（Deadlock）和饑餓（Starvation）等并發(fā)編程中的經(jīng)典問題。

如果所有哲學(xué)家同時都想獲取餐具，但每個哲學(xué)家只能等待旁邊的哲學(xué)家放下筷子才能獲取餐具，這可能會導(dǎo)致死鎖。

如果所有哲學(xué)家只有在其他人都吃到飯才能拿到自己的餐具，那么有些哲學(xué)家可能會因為等待時間太長而饑餓。

代碼案例：

有兩個哲學(xué)家在進行就餐，哲學(xué)家1獲取到筷子1后繼續(xù)嘗試獲取筷子2，哲學(xué)家2獲取到筷子2后繼續(xù)嘗試獲取筷子1，造成了死鎖狀態(tài)。

public class DeadlockDemo {
        public static void main(String[] args) {
            Object obj1 = new Object();//筷子1
            Object obj2 = new Object();//筷子2
            // 線程1獲取obj1，然后等待obj2
            Thread thread1 = new Thread(() -> {
                synchronized (obj1) {
                    System.out.println(Thread.currentThread().getName() + " 獲取 obj1鎖");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj2) {
                        System.out.println(Thread.currentThread().getName() + " 獲取 obj2鎖");
                    }
                }
            }, "哲學(xué)家 1");
            // 線程2獲取obj2，然后等待obj1
            Thread thread2 = new Thread(() -> {
                synchronized (obj2) {
                    System.out.println(Thread.currentThread().getName() + " 獲取 obj2鎖");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj1) {
                        System.out.println(Thread.currentThread().getName() + " 獲取 obj1鎖");
                    }
                }
            }, "哲學(xué)家 2");
            t1.start();
            t2.start();
        }
}

運行后打印：

上述代碼，中 thread1 是哲學(xué)家1，thread2 是哲學(xué)家2，obj1 鎖和 obj2 鎖分別代表兩只筷子。

哲學(xué)家1 占用了 obj1 鎖，哲學(xué)家2 占用了 obj2 鎖。

此時哲學(xué)家1 在擁有 obj1 時獲取 obj2 是獲取不到的，哲學(xué)家2 在擁有 obj2 時獲取 obj1 也是獲取不到的。

這樣就會造成死鎖。也就是本篇文章開頭所說的，一個線程處于永久獲取到鎖的狀態(tài)，其他線程無限阻塞等待，這就造成了死鎖。

2.1 造成死鎖的原因

互斥：一個資源只能被一個進程獨占，即該資源只能被一個進程占有或使用。
請求和保持：進程已經(jīng)保持了至少一個資源，并還在嘗試獲取其他進程保持的資源。
不可搶占：某個資源只能由占有它的線程釋放，不能被其他線程強制占有或搶占。
循環(huán)等待：假設(shè)一個隊列有{t1，t2，t3}這三個線程，t1 等待 t2 所占資源，t2 等待 t3 所占資源，t3 等待 t1 所占資源，這樣就會造成循環(huán)等待。

2.2 解決死鎖問題

解決死鎖問題，最好的方式就是預(yù)防死鎖。我們把鎖按照順序進行編號，并且約定每個線程在獲取多把鎖的時候必須先獲取編號小的，后獲取編號大的。這樣就不會形成死鎖了。

因為，最先獲取編號小鎖的線程會優(yōu)先完成相應(yīng)任務(wù)。輪到其他線程再獲取小編號鎖時，鎖就處于空閑狀態(tài)了。

代碼案例：

public class DeadlockDemo {
        public static void main(String[] args) {
            Object obj1 = new Object();//筷子1
            Object obj2 = new Object();//筷子2
            Thread t1 = new Thread(() -> {
                synchronized (obj1) {
                    System.out.println(Thread.currentThread().getName() + " 獲取 obj1鎖");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj2) {
                        System.out.println(Thread.currentThread().getName() + " 獲取 obj2鎖");
                    }
                }
            }, "哲學(xué)家 1");
            Thread t2 = new Thread(() -> {
                synchronized (obj1) {
                    System.out.println(Thread.currentThread().getName() + " 獲取 obj2鎖");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj2) {
                        System.out.println(Thread.currentThread().getName() + " 獲取 obj1鎖");
                    }
                }
            }, "哲學(xué)家 2");
            t1.start();
            t2.start();
        }
}

運行后打?。?/p>