多線程之死鎖就是這么簡單

winterdawn 發布于2019-08-16 11:14 / 2540人閱讀

摘要：此時線程需要鎖才能繼續往下執行。但是線程的鎖并沒有釋放，線程的鎖也沒有釋放。

前言

只有光頭才能變強

回顧前面：

ThreadLocal就是這么簡單

多線程三分鐘就可以入個門了！

多線程基礎必要知識點！看了學習多線程事半功倍

Java鎖機制了解一下

AQS簡簡單單過一遍

Lock鎖子類了解一下

線程池你真不來了解一下嗎？

本篇主要是講解死鎖，這是我在多線程的最后一篇了。主要將多線程的基礎過一遍，以后有機會再繼續深入！

死鎖是在多線程中也是比較重要的知識點了！

那么接下來就開始吧，如果文章有錯誤的地方請大家多多包涵，不吝在評論區指正哦~

聲明：本文使用JDK1.8

一、死鎖講解

在Java中使用多線程，就會有可能導致死鎖問題。死鎖會讓對應產生死鎖的線程卡住，不再程序往下執行。我們只能通過中止并重啟的方式來讓程序重新執行。

這是我們非常不愿意看到的一種現象，我們要盡可能避免死鎖的情況發生！

造成死鎖的原因可以概括成三句話：

當前線程擁有其他線程需要的資源

當前線程等待其他線程已擁有的資源

都不放棄自己擁有的資源

1.1鎖順序死鎖

首先我們來看一下最簡單的死鎖(鎖順序死鎖)是怎么樣發生的：

public class LeftRightDeadlock {
    private final Object left = new Object();
    private final Object right = new Object();

    public void leftRight() {
        // 得到left鎖
        synchronized (left) {
            // 得到right鎖
            synchronized (right) {
                doSomething();
            }
        }
    }

    public void rightLeft() {
        // 得到right鎖
        synchronized (right) {
            // 得到left鎖
            synchronized (left) {
                doSomethingElse();
            }
        }
    }
}

我們的線程是交錯執行的，那么就很有可能出現以下的情況：

線程A調用leftRight()方法，得到left鎖

同時線程B調用rightLeft()方法，得到right鎖

線程A和線程B都繼續執行，此時線程A需要right鎖才能繼續往下執行。此時線程B需要left鎖才能繼續往下執行。

但是：線程A的left鎖并沒有釋放，線程B的right鎖也沒有釋放。

所以他們都只能等待，而這種等待是無期限的-->永久等待-->死鎖

1.2動態鎖順序死鎖

我們看一下下面的例子，你認為會發生死鎖嗎？

    // 轉賬
    public static void transferMoney(Account fromAccount,
                                     Account toAccount,
                                     DollarAmount amount)
            throws InsufficientFundsException {

        // 鎖定匯賬賬戶
        synchronized (fromAccount) {
            // 鎖定來賬賬戶
            synchronized (toAccount) {

                // 判余額是否大于0
                if (fromAccount.getBalance().compareTo(amount) < 0) {
                    throw new InsufficientFundsException();
                } else {

                    // 匯賬賬戶減錢
                    fromAccount.debit(amount);

                    // 來賬賬戶增錢
                    toAccount.credit(amount);
                }
            }
        }
    }

上面的代碼看起來是沒有問題的：鎖定兩個賬戶來判斷余額是否充足才進行轉賬！

但是，同樣有可能會發生死鎖：

如果兩個線程同時調用transferMoney()

線程A從X賬戶向Y賬戶轉賬

線程B從賬戶Y向賬戶X轉賬

那么就會發生死鎖。

A:transferMoney(myAccount,yourAccount,10);


B:transferMoney(yourAccount,myAccount,20);

1.3協作對象之間發生死鎖

我們來看一下下面的例子：

public class CooperatingDeadlock {
    // Warning: deadlock-prone!
    class Taxi {
        @GuardedBy("this") private Point location, destination;
        private final Dispatcher dispatcher;

        public Taxi(Dispatcher dispatcher) {
            this.dispatcher = dispatcher;
        }

        public synchronized Point getLocation() {
            return location;
        }

        // setLocation 需要Taxi內置鎖
        public synchronized void setLocation(Point location) {
            this.location = location;
            if (location.equals(destination))
                // 調用notifyAvailable()需要Dispatcher內置鎖
                dispatcher.notifyAvailable(this);
        }

        public synchronized Point getDestination() {
            return destination;
        }

        public synchronized void setDestination(Point destination) {
            this.destination = destination;
        }
    }

    class Dispatcher {
        @GuardedBy("this") private final Set taxis;
        @GuardedBy("this") private final Set availableTaxis;

        public Dispatcher() {
            taxis = new HashSet();
            availableTaxis = new HashSet();
        }

        public synchronized void notifyAvailable(Taxi taxi) {
            availableTaxis.add(taxi);
        }

        // 調用getImage()需要Dispatcher內置鎖
        public synchronized Image getImage() {
            Image image = new Image();
            for (Taxi t : taxis)
                // 調用getLocation()需要Taxi內置鎖
                image.drawMarker(t.getLocation());
            return image;
        }
    }

    class Image {
        public void drawMarker(Point p) {
        }
    }
}

上面的getImage()和setLocation(Point location)都需要獲取兩個鎖的

并且在操作途中是沒有釋放鎖的

這就是隱式獲取兩個鎖(對象之間協作)..

這種方式也很容易就造成死鎖.....

二、避免死鎖的方法

避免死鎖可以概括成三種方法：

固定加鎖的順序(針對鎖順序死鎖)

開放調用(針對對象之間協作造成的死鎖)

使用定時鎖-->tryLock()

如果等待獲取鎖時間超時，則拋出異常而不是一直等待！

2.1固定鎖順序避免死鎖

上面transferMoney()發生死鎖的原因是因為加鎖順序不一致而出現的~

正如書上所說的：如果所有線程以固定的順序來獲得鎖，那么程序中就不會出現鎖順序死鎖問題！

那么上面的例子我們就可以改造成這樣子：

public class InduceLockOrder {

    // 額外的鎖、避免兩個對象hash值相等的情況(即使很少)
    private static final Object tieLock = new Object();

    public void transferMoney(final Account fromAcct,
                              final Account toAcct,
                              final DollarAmount amount)
            throws InsufficientFundsException {
        class Helper {
            public void transfer() throws InsufficientFundsException {
                if (fromAcct.getBalance().compareTo(amount) < 0)
                    throw new InsufficientFundsException();
                else {
                    fromAcct.debit(amount);
                    toAcct.credit(amount);
                }
            }
        }
        // 得到鎖的hash值
        int fromHash = System.identityHashCode(fromAcct);
        int toHash = System.identityHashCode(toAcct);

        // 根據hash值來上鎖
        if (fromHash < toHash) {
            synchronized (fromAcct) {
                synchronized (toAcct) {
                    new Helper().transfer();
                }
            }

        } else if (fromHash > toHash) {// 根據hash值來上鎖
            synchronized (toAcct) {
                synchronized (fromAcct) {
                    new Helper().transfer();
                }
            }
        } else {// 額外的鎖、避免兩個對象hash值相等的情況(即使很少)
            synchronized (tieLock) {
                synchronized (fromAcct) {
                    synchronized (toAcct) {
                        new Helper().transfer();
                    }
                }
            }
        }
    }
}

得到對應的hash值來固定加鎖的順序，這樣我們就不會發生死鎖的問題了！

2.2開放調用避免死鎖

在協作對象之間發生死鎖的例子中，主要是因為在調用某個方法時就需要持有鎖，并且在方法內部也調用了其他帶鎖的方法！

如果在調用某個方法時不需要持有鎖，那么這種調用被稱為開放調用！

我們可以這樣來改造：

同步代碼塊最好僅被用于保護那些涉及共享狀態的操作！


class CooperatingNoDeadlock {
    @ThreadSafe
    class Taxi {
        @GuardedBy("this") private Point location, destination;
        private final Dispatcher dispatcher;

        public Taxi(Dispatcher dispatcher) {
            this.dispatcher = dispatcher;
        }

        public synchronized Point getLocation() {
            return location;
        }

        public synchronized void setLocation(Point location) {
            boolean reachedDestination;

            // 加Taxi內置鎖
            synchronized (this) {
                this.location = location;
                reachedDestination = location.equals(destination);
            }
            // 執行同步代碼塊后完畢，釋放鎖



            if (reachedDestination)
                // 加Dispatcher內置鎖
                dispatcher.notifyAvailable(this);
        }

        public synchronized Point getDestination() {
            return destination;
        }

        public synchronized void setDestination(Point destination) {
            this.destination = destination;
        }
    }

    @ThreadSafe
    class Dispatcher {
        @GuardedBy("this") private final Set taxis;
        @GuardedBy("this") private final Set availableTaxis;

        public Dispatcher() {
            taxis = new HashSet();
            availableTaxis = new HashSet();
        }

        public synchronized void notifyAvailable(Taxi taxi) {
            availableTaxis.add(taxi);
        }

        public Image getImage() {
            Set copy;

            // Dispatcher內置鎖
            synchronized (this) {
                copy = new HashSet(taxis);
            }
            // 執行同步代碼塊后完畢，釋放鎖

            Image image = new Image();
            for (Taxi t : copy)
                // 加Taix內置鎖
                image.drawMarker(t.getLocation());
            return image;
        }
    }

    class Image {
        public void drawMarker(Point p) {
        }
    }

}

使用開放調用是非常好的一種方式，應該盡量使用它~

2.3使用定時鎖

使用顯式Lock鎖，在獲取鎖時使用tryLock()方法。當等待超過時限的時候，tryLock()不會一直等待，而是返回錯誤信息。

使用tryLock()能夠有效避免死鎖問題~~

2.4死鎖檢測

雖然造成死鎖的原因是因為我們設計得不夠好，但是可能寫代碼的時候不知道哪里發生了死鎖。

JDK提供了兩種方式來給我們檢測：

JconsoleJDK自帶的圖形化界面工具，使用JDK給我們的的工具JConsole

Jstack是JDK自帶的命令行工具，主要用于線程Dump分析。

具體可參考：

https://www.cnblogs.com/flyingeagle/articles/6853167.html

三、總結

發生死鎖的原因主要由于：

線程之間交錯執行

解決：以固定的順序加鎖

執行某方法時就需要持有鎖，且不釋放

解決：縮減同步代碼塊范圍，最好僅操作共享變量時才加鎖

永久等待

解決：使用tryLock()定時鎖，超過時限則返回錯誤信息

在操作系統層面上看待死鎖問題(這是我之前做的筆記、很淺顯)：

操作系統第五篇【死鎖】

參考資料：

《Java核心技術卷一》

《Java并發編程實戰》

《計算機操作系統湯小丹》

如果文章有錯的地方歡迎指正，大家互相交流。習慣在微信看技術文章，想要獲取更多的Java資源的同學，可以關注微信公眾號:Java3y。為了大家方便，剛新建了一下qq群：742919422，大家也可以去交流交流。謝謝支持了！希望能多介紹給其他有需要的朋友

文章的目錄導航：

https://zhongfucheng.bitcron.com/post/shou-ji/wen-zhang-dao-hang

云服務器 GPU云服務器多線程死鎖簡單多線程服務器編碼 linux就是這么學線程死鎖

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/71107.html

超詳細的Java面試題總結（二）之Java基礎知識篇

摘要：超詳細的面試題總結一之基本知識多線程和虛擬機創建線程有幾種不同的方式你喜歡哪一種為什么繼承類實現接口應用程序可以使用框架來創建線程池實現接口。死亡線程方法執行結束，或者因異常退出了方法，則該線程結束生命周期。死亡的線程不可再次復生。超詳細的Java面試題總結（一）之Java基本知識多線程和Java虛擬機創建線程有幾種不同的方式？你喜歡哪一種？為什么？繼承Thread類實現R...

wangjuntytl 2019-08-15 14:54 評論0 收藏0
多線程編程完全指南

摘要：在這個范圍廣大的并發技術領域當中多線程編程可以說是基礎和核心，大多數抽象并發問題的構思與解決都是基于多線程模型來進行的。一般來說，多線程程序會面臨三類問題正確性問題效率問題死鎖問題。多線程編程或者說范圍更大的并發編程是一種非常復雜且容易出錯的編程方式，但是我們為什么還要冒著風險艱辛地學習各種多線程編程技術、解決各種并發問題呢？因為并發是整個分布式集群的基礎，通過分布式集群不僅可以大...

mengera88 2019-08-19 11:47 評論0 收藏0
Java基礎學習——多線程之線程間通信（安全問題、等待喚醒機制）

摘要：線程間通信其實就是多個線程操作同一個資源，但動作不同。同步前提是多線程。將該線程載入線程池，等待喚醒。該方法拋出異常，故需要配合使用隨機喚醒線程池中一線程。線程為了檢測死鎖，它需要遞進地檢測所有被請求的鎖。線程間通信其實就是多個線程操作同一個資源，但動作不同。示例：在某個數據庫中，Input輸入人的姓名，性別，Output輸出，兩個線程同時作用。思考：1.明確哪些代碼是多線程操作的...

CocoaChina 2019-08-16 10:26 評論0 收藏0
解決死鎖的100種方法

摘要：雖然本文是一篇介紹死鎖及其解決方式的文章，但是對于多線程程序中的非死鎖問題我們也應該有所了解，這樣才能寫出正確且高效的多線程程序。死鎖是多線程編程或者說是并發編程中的一個經典問題，也是我們在實際工作中很可能會碰到的問題。相信大部分讀者對死鎖這個詞都是略有耳聞的，但從我對后端開發崗位的面試情況來看很多同學往往對死鎖都還沒有系統的了解。雖然死鎖聽起來很高深，但是實際上已經被研究得比較透徹...

caige 2019-08-16 16:51 評論0 收藏0
(十四)java多線程之死鎖以及解決方案

摘要：本人郵箱歡迎轉載轉載請注明網址代碼已經全部托管有需要的同學自行下載引言多線程如果設計的不合理的話很可能就會出現死鎖當兩個或者多個線程同事想要去獲取共享資源的鎖時但每個線程都要等其他線程把他們各自的鎖給釋放才能繼續運行這就是死鎖出現死鎖必須具本人郵箱: 歡迎轉載,轉載請注明網址 http://blog.csdn.net/tianshi_kcogithub: https://github...

wendux 2019-08-14 18:10 評論0 收藏0