Java多線程編程中的并發安全問題怎么解決

本篇內容主要講解“Java多線程編程中的并發安全問題怎么解決”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Java多線程編程中的并發安全問題怎么解決”吧!

線程安全性

線程安全是指我們所寫的代碼在并發情況下使用時，總是能表現出正確的行為；反之，未實現線程安全的代碼，表現的行為是不可預知的，有可能正確，

實現線程安全的方式：

線程封閉

就是把對象封裝到一個線程里，只有這一個線程能看到此對象。實現線程封閉的方式如下：

棧封閉

這里是指每個線程自己的線程棧，方法的局部變量就是在線程棧中的，對于其他線程是不可見的

ThreadLocal

各個線程Thread對象維護了一份Map，對于其他線程是不可見的

無狀態的類

沒有任何成員變量的類，就叫無狀態的類，這種類一定是線程安全的。

讓類不可變

沒有成員變量的類畢竟是少數，我們還可以讓類的成員變量不可變，給他們加上final關鍵字

如果成員變量是一個對象，final不能保證類的安全性，因為雖然對象的引用不會變，但是在堆上的對象實例可能被多個線程同時修改，沒有正確處理的情況下，對象實例在堆中的數據是不可預知的。

加鎖或CAS

synchronized、顯示鎖Look、原子Atomic操作、CAS機制等等

死鎖

定義

是指兩個或兩個以上的進程在執行過程中，由于競爭資源或者由于彼此通信而造成的一種阻塞的現象，若無外力作用，它們都將無法推進下去。此時稱系統處于死鎖狀態或系統產生了死鎖。

• 死鎖是必然發生在多操作者（M>=2 個）爭奪多個資源（N>=2 個，且 N<=M） 才會發生這種情況。

• 爭奪資源的順序不對，如果爭奪資源的順序是一樣的，也不會產生死鎖；

• 爭奪者對拿到的資源不放手，也不能被掠奪。

學術化的定義。死鎖的發生必須具備以下四個必要條件。

• 互斥條件：指進程對所分配到的資源進行排它性使用，即在一段時間內某資源只由一個進程占用。如果此時還有其它進程請求資源，則請求者只能等待， 直至占有資源的進程用畢釋放。

• 請求和保持條件：指進程已經保持至少一個資源，但又提出了新的資源請求，而該資源已被其它進程占有，此時請求進程阻塞，但又對自己已獲得的其它資源保持不放。

• 不剝奪條件：指進程已獲得的資源，在未使用完之前，不能被剝奪，只能在使用完時由自己釋放。

• 環路等待條件：指在發生死鎖時，必然存在一個進程&mdash;&mdash;資源的環形鏈， 即進程集合{P0，P1，P2，&middot;&middot;&middot;，Pn}中的 P0 正在等待一個 P1 占用的資源；P1 正在等待 P2 占用的資源，&hellip;&hellip;，Pn 正在等待已被 P0 占用的資源。

只要打破四個必要條件之一就能有效預防死鎖的發生。

• 打破互斥條件：改造獨占性資源為虛擬資源，大部分資源已無法改造。

• 打破不可搶占條件：當一進程占有一獨占性資源后又申請一獨占性資源而無 法滿足，則退出原占有的資源。

• 打破占有且申請條件：采用資源預先分配策略，即進程運行前申請全部資源， 滿足則運行，不然就等待，這樣就不會占有且申請。

• 打破循環等待條件：實現資源有序分配策略，對所有設備實現分類編號，所有進程只能采用按序號遞增的形式申請資源。

避免死鎖常見的算法有有序資源分配法、銀行家算法。

實現一個死鎖

/**
 * @Description: 實現一個簡單的死鎖程序
 */
public class DeadLookTest {
    private static Object o1 = new Object();
    private static Object o2 = new Object();
    public void fastLock() throws InterruptedException {
        synchronized(o1){
            Thread.sleep(2000);
            System.out.println("fast");
            synchronized (o2){
                System.out.println("----");
            }
        }
    }
    public void postLock() throws InterruptedException {
        synchronized(o2){
            Thread.sleep(2000);
            System.out.println("post");
            synchronized (o1){
                System.out.println("----");
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        DeadLookTest deadlook = new DeadLookTest();
        // 新開一個線程去調用其中一個方法
        new Thread(() -> {
            try {
                deadlook.postLock();
            } catch (InterruptedException e) {
            }
        }).start();
        deadlook.fastLock();
    }
}

查看死鎖

使用jstack命令查看死鎖結果

C:\Users\Administrator>jps
4784 DeadLookTest
9808 RemoteMavenServer36
2052 Launcher
2692 Jps
8572

C:\Users\Administrator>jstack 4784
......
Found one Java-level deadlock:
=============================
"Thread-0":
  waiting to lock monitor 0x0000025d5a58fd88 (object 0x0000000716edb910, a java.lang.Object),
  which is held by "main"
"main":
  waiting to lock monitor 0x0000025d5a58e998 (object 0x0000000716edb920, a java.lang.Object),
  which is held by "Thread-0"

Java stack information for the threads listed above:
===================================================
"Thread-0":
        at cn.tulingxueyuan.safe.dl.DeadLookTest.postLock(DeadLookTest.java:30)
        - waiting to lock <0x0000000716edb910> (a java.lang.Object)
        - locked <0x0000000716edb920> (a java.lang.Object)
        at cn.tulingxueyuan.safe.dl.DeadLookTest.lambda$main$0(DeadLookTest.java:39)
        at cn.tulingxueyuan.safe.dl.DeadLookTest$$Lambda$1/2003749087.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)
"main":
        at cn.tulingxueyuan.safe.dl.DeadLookTest.fastLock(DeadLookTest.java:20)
        - waiting to lock <0x0000000716edb920> (a java.lang.Object)
        - locked <0x0000000716edb910> (a java.lang.Object)
        at cn.tulingxueyuan.safe.dl.DeadLookTest.main(DeadLookTest.java:43)

Found 1 deadlock.

解決死鎖

我們現在通過上面的命令找到了產生死鎖的位置，那么如何取解決死鎖嘞？我們知道產生死鎖的原因如下：

• 死鎖是必然發生在多操作者（M>=2 個）爭奪多個資源（N>=2 個，且 N<=M） 才會發生這種情況。

• 爭奪資源的順序不對，如果爭奪資源的順序是一樣的，也不會產生死鎖；

• 爭奪者對拿到的資源不放手，也不能被掠奪。

第一個條件一般都是業務必須要，那么打破死鎖就要從下面的兩個條件去解決

• 保證爭奪鎖資源的順序一樣。

在實際的開發中可能會存在比較隱蔽的加鎖順序，比如鎖對象作為方法參數傳遞，如下所示

private static void businessDo(Object first,Object second) throws InterruptedException {
    String threadName = Thread.currentThread().getName();
    synchronized (first){
        System.out.println(threadName + " get first");
        Thread.sleep(1000);
        synchronized (second){
            System.out.println(threadName + " get second");
        }
    }
}
// 然后兩個線程，在調用的時候傳遞的參數順序卻不一樣
businessDo(No1,No2);
businessDo(No2,No1);

解決上面這種問題的方式是：在加鎖前，在方法中做一個內部的排序

public class SafeOperate {
    private static Object No13 = new Object();//第一個鎖
    private static Object No14 = new Object();//第二個鎖
    private static Object tieLock = new Object();//第三把鎖
    public void transfer(Object first,Object second) throws InterruptedException {
        int firstHash = System.identityHashCode(first);
        int secondHash = System.identityHashCode(second);
        if(firstHash<secondHash){
            synchronized (first){
                System.out.println(Thread.currentThread().getName()+" get "+first);
                Thread.sleep(100);
                synchronized (second){
                    System.out.println(Thread.currentThread().getName()+" get "+second);
                }
            }
        }else if(secondHash<firstHash){
            synchronized (second){
                System.out.println(Thread.currentThread().getName()+" get"+second);
                Thread.sleep(100);
                synchronized (first){
                    System.out.println(Thread.currentThread().getName()+" get"+first);
                }
            }
        }else{
            // 萬一兩個對象的hash值一樣，那么就引入第三把鎖，誰先搶到第三把鎖就去進行前兩兩把鎖的加鎖
            synchronized (tieLock){
                synchronized (first){
                    synchronized (second){
                        System.out.println(Thread.currentThread().getName()+" get"+first);
                        System.out.println(Thread.currentThread().getName()+" get"+second);
                    }
                }
            }
        }
    }
}

對拿到的鎖資源嘗試釋放

這種方式對于synchronized是不適用的，因為它不拿到鎖誓不罷休。使用ReentrantLock，使用其中的tryLock(long time, TimeUnit unit)方法，在指定的時間中如果還沒有拿到鎖就去進行釋放的邏輯

大致是實現邏輯如下所示

while(true){
    if(No13.tryLock()){
        System.out.println(threadName +" get 13");
        // 如果沒有拿到No14的鎖，那么No13的鎖也釋放
        try{
            if(No14.tryLock()){
                try{
                    System.out.println(threadName  +" get 14");
                    System.out.println("zhouYuDo do work------------");
                    break;
                }finally{
                    No14.unlock();
                }
            }
        }finally {
            No13.unlock();
        }
    }
    // 如果不加休眠機制，那么就比較容易產生活鎖
    Thread.sleep(1000);
}

其他線程安全問題

活鎖

兩個線程在嘗試拿鎖的機制中，發生多個線程之間互相謙讓，不斷發生同一個線程總是拿到同一把鎖，在嘗試拿另一把鎖時因為拿不到，而將本來已經持有的鎖釋放的過程。

解決辦法：每個線程休眠隨機數，錯開拿鎖的時間。

線程饑餓

低優先級的線程，總是拿不到執行時間

單例模式

• DCL雙重檢測機制

• volatile關鍵字禁止指令重排

public class HungrySingleton {
    //創建 SingletonHungry 的一個對象
    private static volatile HungrySingleton instance;
    // 讓構方法私有，這樣該類就不會被其它類實例化
    private HungrySingleton() {
    }
    //獲取唯一可用的對象
    public static HungrySingleton getInstance() {
        if(null == instance) { 
            synchronized{
                if(null == instance) { 
                    instance = new LazySingleton();
                }
            }
        }
    	return instance;
    }
}

到此，相信大家對“Java多線程編程中的并發安全問題怎么解決”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！