如何解決Java多線程死鎖問題

更新時間：2021年05月13日 09:32:23 作者：Putarmor

死鎖是一個很嚴重的、必須要引起重視的問題，本文主要介紹了死鎖的定義，解決方法和面試會遇到的問題，感興趣的可以了解一下

死鎖問題

死鎖定義

多線程編程中，因為搶占資源造成了線程無限等待的情況，此情況稱為死鎖。

死鎖舉例

注意：線程和鎖的關(guān)系是：一個線程可以擁有多把鎖，一個鎖只能被一個線程擁有。

當兩個線程分別擁有一把各自的鎖之后，又嘗試去獲取對方的鎖，這樣就會導致死鎖情況的發(fā)生，具體先看下面代碼：

/**
 * 線程死鎖問題
 */
public class DeadLock {
    public static void main(String[] args) {
        //創(chuàng)建兩個鎖對象
        Object lock1 = new Object();
        Object lock2 = new Object();

        //創(chuàng)建子線程
        /*
        線程1：①先獲得鎖1 ②休眠1s，讓線程2獲得鎖2 ③線程1嘗試獲取鎖2 線程2同理
         */
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //線程1業(yè)務(wù)邏輯
                synchronized(lock1){
                    System.out.println("線程1得到了鎖子1");
                    try {
                        //休眠1s，讓線程2先得到鎖2
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("線程1嘗試獲取鎖2...");
                    synchronized(lock2){
                        System.out.println("線程1獲得了鎖2!");
                    }
                }
            }
        },"線程1");


        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //線程2業(yè)務(wù)邏輯
                synchronized(lock2){
                    System.out.println("線程2得到了鎖子2");
                    try {
                //休眠1s，讓線程1先得到鎖1；因為線程是并發(fā)執(zhí)行我們不知道誰先執(zhí)行
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("線程2嘗試獲取鎖1...");
                    synchronized(lock1){
                        System.out.println("線程2獲得了鎖1");
                    }
                }
            }
        },"線程2");
        thread1.start();
        thread2.start();
    }
}

程序運行結(jié)果如下：

在這里插入圖片描述

可以看出，線程1嘗試獲取了鎖2，線程2嘗試獲取了鎖1，但是二者并沒有獲取到對方的鎖；這就發(fā)生了所謂的“死鎖”！

如何排查死鎖

想要排查死鎖具體細節(jié)，可以通過三個工具（位于jdk安裝路徑bin目錄）去排查，現(xiàn)在就給大家介紹一下：

1.jconsole

在這里插入圖片描述

可以看出，線程1和線程2發(fā)生了死鎖，死鎖發(fā)生的位置一目了然

2.jvisualvm

在這里插入圖片描述

可以看出，發(fā)生了死鎖，線程1和線程2嘗試獲取的鎖是對方的鎖。

3.jmc

在這里插入圖片描述

可以看出，同樣檢測出了死鎖情況
無論是用哪個工具排查死鎖情況都是OK的。

死鎖發(fā)生的條件

1.互斥條件（一個鎖只能被一個線程占有，當一個鎖被一個線程持有之后，不能再被其他線程持有）；
2.請求擁有（一個線程擁有一把鎖之后，又去嘗試請求擁有另外一把鎖）；可以解決
3.不可剝奪（一個鎖被一個線程占有之后，如果該線程沒有釋放鎖，其他線程不能強制獲得該鎖）；
4.環(huán)路等待條件（多線程獲取鎖時形成了一個環(huán)形鏈）可以解決

怎么解決死鎖問題？

環(huán)路等待條件相對于請求擁有更容易實現(xiàn)，那么通過破壞環(huán)路等待條件解決死鎖問題
破壞環(huán)路等待條件示意圖：

在這里插入圖片描述

針對于上面死鎖舉例中代碼，解決死鎖，具體看下面代碼：

/**
 * 線程死鎖問題
 */
public class DeadLock {
    public static void main(String[] args) {
        //創(chuàng)建兩個鎖對象
        Object lock1 = new Object();
        Object lock2 = new Object();

        //創(chuàng)建子線程
        /*
        線程1：①先獲得鎖1 ②休眠1s，讓線程2獲得鎖2 ③線程1嘗試獲取鎖2 線程2同理
         */
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //線程1業(yè)務(wù)邏輯
                synchronized(lock1){
                    System.out.println("線程1得到了鎖子1");
                    try {
                        //休眠1s，讓線程2先得到鎖2
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("線程1嘗試獲取鎖2...");
                    synchronized(lock2){
                        System.out.println("線程1獲得了鎖2!");
                    }
                }
            }
        },"線程1");


        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //線程2業(yè)務(wù)邏輯
                synchronized(lock2){
                    System.out.println("線程2得到了鎖子2");
                    try {
                //休眠1s，讓線程1先得到鎖1；因為線程是并發(fā)執(zhí)行我們不知道誰先執(zhí)行
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("線程2嘗試獲取鎖1...");
                    synchronized(lock1){
                        System.out.println("線程2獲得了鎖1");
                    }
                }
            }
        },"線程2");
        thread1.start();
        thread2.start();
    }
}

程序運行結(jié)果如下：

在這里插入圖片描述

可以看出，通過破壞環(huán)路等待條件完美解決了死鎖問題

線程通訊機制（wait/notify/notifyAll）

定義

線程通訊機制：一個線程的動作可以讓另外一個線程感知到，這就是線程通訊機制。
wait()：讓當前線程進入休眠等待狀態(tài)；
notify()：喚醒當前對象上的休眠等待線程；
notifyAll()：喚醒當前對象上的所有休眠等待線程。

LockSupport

LockSupport是對wait()的升級，無需加鎖也無需釋放鎖；

LockSupport.park()讓線程休眠，和wait()一樣會讓線程進入WAITING狀態(tài)；LockSupport.unpark()喚醒線程，可以喚醒對象上指定的休眠等待線程；（優(yōu)勢）

LockSupport與wait()區(qū)別

wait()與LockSupport的區(qū)別：

相同點：
1.二者都可以讓線程進入休眠等待狀態(tài)；
2.二者都可以傳參或者不傳參，讓線程都會進入到WAITING狀態(tài)。
不同點：
1.wait()需要配合加鎖一起使用，LockSupport無需加鎖；
2.wait()只能喚醒對象的隨機休眠線程和全部線程，LockSupport可以喚醒對象的指定休眠線程。

到此這篇關(guān)于如何解決Java多線程死鎖問題的文章就介紹到這了,更多相關(guān)Java多線程死鎖內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: