Java併發編程，你須要知道的

時間 2019-11-17

標籤 java 併發編程須要知道欄目 Java 简体版

原文原文鏈接

本文大綱

1.併發編程三要素

原子性 原子，即一個不可再被分割的顆粒。在Java中原子性指的是一個或多個操做要麼所有執行成功要麼所有執行失敗。
有序性 程序執行的順序按照代碼的前後順序執行。（處理器可能會對指令進行重排序）
可見性 當多個線程訪問同一個變量時，若是其中一個線程對其做了修改，其餘線程能當即獲取到最新的值。

2. 線程的五大狀態

建立狀態 當用 new 操做符建立一個線程的時候
就緒狀態 調用 start 方法，處於就緒狀態的線程並不必定立刻就會執行 run 方法，還須要等待CPU的調度
運行狀態 CPU 開始調度線程，並開始執行 run 方法
阻塞狀態 線程的執行過程當中因爲一些緣由進入阻塞狀態好比：調用 sleep 方法、嘗試去獲得一個鎖等等
死亡狀態 run 方法執行完或者執行過程當中遇到了一個異常

3.悲觀鎖與樂觀鎖

悲觀鎖：每次操做都會加鎖，會形成線程阻塞。
樂觀鎖：每次操做不加鎖而是假設沒有衝突而去完成某項操做，若是由於衝突失敗就重試，直到成功爲止，不會形成線程阻塞。

4.線程之間的協做

4.1 wait/notify/notifyAll

這一組是 Object 類的方法須要注意的是：這三個方法都必須在同步的範圍內調用html

wait 阻塞當前線程，直到 notify 或者 notifyAll 來喚醒java

wait有三種方式的調用
wait()
必要要由 notify 或者 notifyAll 來喚醒
wait(long timeout)
在指定時間內，若是沒有notify或notifAll方法的喚醒，也會自動喚醒。
wait(long timeout,long nanos)
本質上仍是調用一個參數的方法
public final void wait(long timeout, int nanos) throws InterruptedException {
      if (timeout < 0) {
             throw new IllegalArgumentException("timeout value is negative");
       }
      if (nanos < 0 || nanos > 999999) {
              throw new IllegalArgumentException(
             "nanosecond timeout value out of range");
       }
       if (nanos > 0) {
             timeout++;
       }
       wait(timeout);
}
              
複製代碼

notify 只能喚醒一個處於 wait 的線程
notifyAll 喚醒所有處於 wait 的線程

4.2 sleep/yield/join

這一組是 Thread 類的方法面試

sleep 讓當前線程暫停指定時間，只是讓出CPU的使用權，並不釋放鎖編程

yield 暫停當前線程的執行，也就是當前CPU的使用權，讓其餘線程有機會執行，不能指定時間。會讓當前線程從運行狀態轉變爲就緒狀態，此方法在生產環境中不多會使用到，官方在其註釋中也有相關的說明緩存

/**
      * A hint to the scheduler that the current thread is willing to yield
      * its current use of a processor. The scheduler is free to ignore this
      * hint.
      *
      * <p> Yield is a heuristic attempt to improve relative progression
      * between threads that would otherwise over-utilise a CPU. Its use
      * should be combined with detailed profiling and benchmarking to
      * ensure that it actually has the desired effect.
      *
      * <p> It is rarely appropriate to use this method. It may be useful
      * for debugging or testing purposes, where it may help to reproduce
      * bugs due to race conditions. It may also be useful when designing
      * concurrency control constructs such as the ones in the
      * {@link java.util.concurrent.locks} package.
      */
      
複製代碼

join 等待調用 join 方法的線程執行結束，才執行後面的代碼其調用必定要在 start 方法以後（看源碼可知）使用場景：當父線程須要等待子線程執行結束才執行後面內容或者須要某個子線程的執行結果會用到 join 方法多線程

5.valitate 關鍵字

5.1 定義

java編程語言容許線程訪問共享變量，爲了確保共享變量能被準確和一致的更新，線程應該確保經過排他鎖單獨得到這個變量。Java語言提供了volatile，在某些狀況下比鎖更加方便。若是一個字段被聲明成volatile，java線程內存模型確保全部線程看到這個變量的值是一致的。併發

valitate是輕量級的synchronized，不會引發線程上下文的切換和調度，執行開銷更小。app

5.2 原理

使用volitate修飾的變量在彙編階段，會多出一條lock前綴指令
它確保指令重排序時不會把其後面的指令排到內存屏障以前的位置，也不會把前面的指令排到內存屏障的後面；即在執行到內存屏障這句指令時，在它前面的操做已經所有完成
它會強制將對緩存的修改操做當即寫入主存
若是是寫操做，它會致使其餘CPU裏緩存了該內存地址的數據無效

5.3 做用

內存可見性 多線程操做的時候，一個線程修改了一個變量的值，其餘線程能當即看到修改後的值異步

防止重排序 即程序的執行順序按照代碼的順序執行（處理器爲了提升代碼的執行效率可能會對代碼進行重排序）編程語言

並不能保證操做的原子性（好比下面這段代碼的執行結果必定不是100000）

public class testValitate {
    public volatile int inc = 0;
    public void increase() {
        inc = inc + 1;
    }
    public static void main(String[] args) {
        final testValitate test = new testValitate();
        for (int i = 0; i < 100; i++) {
            new Thread() {
                public void run() {
                    for (int j = 0; j < 1000; j++)
                        test.increase();
                }
            }.start();
        }
        while (Thread.activeCount() > 2) {  //保證前面的線程都執行完
            Thread.yield();
        }
        System.out.println(test.inc);
     }
   }
複製代碼

6. synchronized 關鍵字

確保線程互斥的訪問同步代碼

6.1 定義

synchronized 是JVM實現的一種鎖，其中鎖的獲取和釋放分別是 monitorenter 和 monitorexit 指令，該鎖在實現上分爲了偏向鎖、輕量級鎖和重量級鎖，其中偏向鎖在 java1.6 是默認開啓的，輕量級鎖在多線程競爭的狀況下會膨脹成重量級鎖，有關鎖的數據都保存在對象頭中

6.2 原理

加了 synchronized 關鍵字的代碼段，生成的字節碼文件會多出 monitorenter 和 monitorexit 兩條指令（利用javap -verbose 字節碼文件可看到關，關於這兩條指令的文檔以下：

monitorenter Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows: • If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor. • If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count. • If another thread already owns the monitor associated with objectref, the thread blocks until the monitor's entry count is zero, then tries again to gain ownership.
monitorexit The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref. The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.

加了 synchronized 關鍵字的方法，生成的字節碼文件中會多一個 ACC_SYNCHRONIZED 標誌位，當方法調用時，調用指令將會檢查方法的 ACC_SYNCHRONIZED 訪問標誌是否被設置，若是設置了，執行線程將先獲取monitor，獲取成功以後才能執行方法體，方法執行完後再釋放monitor。在方法執行期間，其餘任何線程都沒法再得到同一個monitor對象。其實本質上沒有區別，只是方法的同步是一種隱式的方式來實現，無需經過字節碼來完成。

6.3 關於使用

修飾普通方法同步對象是實例對象
修飾靜態方法同步對象是類自己
修飾代碼塊能夠本身設置同步對象

6.4 缺點

會讓沒有獲得鎖的資源進入Block狀態，爭奪到資源以後又轉爲Running狀態，這個過程涉及到操做系統用戶模式和內核模式的切換，代價比較高。Java1.6爲 synchronized 作了優化，增長了從偏向鎖到輕量級鎖再到重量級鎖的過分，可是在最終轉變爲重量級鎖以後，性能仍然較低。

7. CAS

AtomicBoolean，AtomicInteger，AtomicLong以及 Lock 相關類等底層就是用 CAS實現的，在必定程度上性能比 synchronized 更高。

7.1 什麼是CAS

CAS全稱是Compare And Swap，即比較替換，是實現併發應用到的一種技術。操做包含三個操做數 —— 內存位置（V）、預期原值（A）和新值(B)。若是內存位置的值與預期原值相匹配，那麼處理器會自動將該位置值更新爲新值。不然，處理器不作任何操做。

7.2 爲何會有CAS

若是隻是用 synchronized 來保證同步會存在如下問題 synchronized 是一種悲觀鎖，在使用上會形成必定的性能問題。在多線程競爭下，加鎖、釋放鎖會致使比較多的上下文切換和調度延時，引發性能問題。一個線程持有鎖會致使其它全部須要此鎖的線程掛起。

7.3 實現原理

Java不能直接的訪問操做系統底層，是經過native方法（JNI）來訪問。CAS底層經過Unsafe類實現原子性操做。

7.4 存在的問題

ABA問題

什麼是ABA問題？好比有一個 int 類型的值 N 是 1。此時有三個線程想要去改變它：
```
線程A ：但願給 N 賦值爲 2
線程B： 但願給 N 賦值爲 2
線程C： 但願給 N 賦值爲 1
複製代碼
```
此時線程A和線程B同時獲取到N的值1，線程A率先獲得系統資源，將 N 賦值爲 2，線程B因爲某種緣由被阻塞住，線程C在線程A執行完後獲得 N 的當前值2。此時的線程狀態：
- 線程A成功給 N 賦值爲2
- 線程B獲取到 N 的當前值 1 但願給他賦值爲 2，處於阻塞狀態
- 線程C獲取到 N 的當前值2,但願給他賦值爲1，而後線程C成功給N賦值爲1
- 最後線程B獲得了系統資源，又從新恢復了運行狀態，在阻塞以前線程B獲取到的N的值是1，執行compare操做發現當前N的值與獲取到的值相同（均爲1），成功將N賦值爲了2。
在這個過程當中線程B獲取到N的值是一箇舊值，雖然和當前N的值相等，可是實際上N的值已經經歷了一次 1到2到1的改變。

上面這個例子就是典型的ABA問題

怎樣去解決ABA問題
給變量加一個版本號便可，在比較的時候不只要比較當前變量的值還須要比較當前變量的版本號。Java中AtomicStampedReference 就解決了這個問題
循環時間長開銷大在併發量比較高的狀況下，若是許多線程反覆嘗試更新某一個變量，卻又一直更新不成功，循環往復，會給CPU帶來很大的壓力。

CAS只能保證一個共享變量的原子操做

8. AbstractQueuedSynchronizer(AQS)

AQS抽象的隊列式同步器，是一種基於狀態（state）的鏈表管理方式。state 是用CAS去修改的。它是 java.util.concurrent 包中最重要的基石，要學習想學習 java.util.concurrent 包裏的內容這個類是關鍵。 ReentrantLock、CountDownLatcher、Semaphore 實現的原理就是基於AQS。想知道他怎麼實現以及實現原理能夠參看這篇文章https://www.cnblogs.com/waterystone/p/4920797.html

9. Future

在併發編程咱們通常使用Runable去執行異步任務，然而這樣作咱們是不能拿到異步任務的返回值的，可是使用Future 就能夠。使用Future很簡單，只需把Runable換成FutureTask便可。使用上比較簡單，這裏很少作介紹。

10. 線程池

若是咱們使用線程的時候就去建立一個線程，雖然簡單，可是存在很大的問題。若是併發的線程數量不少，而且每一個線程都是執行一個時間很短的任務就結束了，這樣頻繁建立線程就會大大下降系統的效率，由於頻繁建立線程和銷燬線程須要時間。線程池經過複用能夠大大減小線程頻繁建立與銷燬帶來的性能上的損耗。

Java中線程池的實現類 ThreadPoolExecutor，其構造函數的每個參數的含義在註釋上已經寫得很清楚了，這裏幾個關鍵參數能夠再簡單說一下

corePoolSize ：核心線程數即一直保留在線程池中的線程數量，即便處於閒置狀態也不會被銷燬。要設置 allowCoreThreadTimeOut 爲 true，纔會被銷燬。
maximumPoolSize：線程池中容許存在的最大線程數
keepAliveTime ：非核心線程容許的最大閒置時間，超過這個時間就會本地銷燬。
workQueue：用來存聽任務的隊列。
- SynchronousQueue：這個隊列會讓新添加的任務當即獲得執行，若是線程池中全部的線程都在執行，那麼就會去建立一個新的線程去執行這個任務。當使用這個隊列的時候，maximumPoolSizes通常都會設置一個最大值 Integer.MAX_VALUE
- LinkedBlockingQueue：這個隊列是一個無界隊列。怎麼理解呢，就是有多少任務來咱們就會執行多少任務，若是線程池中的線程小於corePoolSize ,咱們就會建立一個新的線程去執行這個任務，若是線程池中的線程數等於corePoolSize，就會將任務放入隊列中等待，因爲隊列大小沒有限制因此也被稱爲無界隊列。當使用這個隊列的時候 maximumPoolSizes 不生效（線程池中線程的數量不會超過corePoolSize），因此通常都會設置爲0。
- ArrayBlockingQueue：這個隊列是一個有界隊列。能夠設置隊列的最大容量。當線程池中線程數大於或者等於 maximumPoolSizes 的時候，就會把任務放到這個隊列中，噹噹前隊列中的任務大於隊列的最大容量就會丟棄掉該任務交由 RejectedExecutionHandler 處理。

最後，本文主要對Java併發編程開發須要的知識點做了簡單的講解，這裏每個知識點均可以用一篇文章去講解，因爲篇幅緣由不能對每個知識點都詳細介紹，我相信經過本文你會對Java的併發編程會有更近一步的瞭解。若是您發現還有缺漏或者有錯誤的地方，能夠在評論區補充，謝謝。