Java同步器之synchronized&Lock&AQS

synchronized關鍵字

1. 什么是synchronized關鍵字

syncronized關鍵字是JVM內置鎖，是物件鎖，對某一部分代碼使用鎖后，這段代碼將被視為原子操作執行，保證多個執行緒對該代碼塊的訪問會按照一定順序先后執行，

2. synchronized關鍵字原理

假設我們對以下代碼進行加鎖：

public class MyTest {
    
    public final static Object o = new Object();
    public static int i = 0;

    public static void main(String[] args) {
        synchronized (o) {
            i++;
        }
    }
}

再使用JDK自帶的javap命令查看該檔案的位元組碼檔案，則會看到以下資訊：

public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field o:Ljava/lang/Object;
       3: dup
       4: astore_1
       5: monitorenter				// ~~~~~~~~~~請注意該行~~~~~~~~~~~~
       6: getstatic     #3                  // Field i:I
       9: iconst_1
      10: iadd
      11: putstatic     #3                  // Field i:I
      14: aload_1
      15: monitorexit				// ~~~~~~~~~~請注意該行~~~~~~~~~~~~
      16: goto          24
      19: astore_2
      20: aload_1
      21: monitorexit
      22: aload_2
      23: athrow
      24: return

這里出現了兩條指令，分別是monitorenter和monitorexit，
這兩條指令分別標識同步塊的開始和結束，而這兩個指令，是由JVM進行添加的，所以synchronized是一個JVM內置鎖，
JVM在識別synchronized關鍵字后，會通過傳入物件的ObjectMonitor進行鎖相關的操作，
這個ObjectMonitor是每個Ojbect被創建的時候都會自動創建到JVM內部的，

加鎖解鎖的程序中，肯定需要記錄鎖的狀態和資訊，因此需要一個記憶體空間用來記錄，
JVM使用物件中的物件頭來記錄物件加鎖解鎖的狀態，
請看下圖：
由圖可見，一個java物件的記憶體結構包含了3部分：

1. 物件頭 ——用來存放各種資訊，比如鎖狀態等
2. 實際資料 ——存放java物件的實際資料
3. 對齊填充位 ——規范Java物件的記憶體空間大小，規定為8的整數倍

緊接著，咱們還可以查看一下JVM的原始碼，可以從網上下載一份原始碼，同時找到下面的檔案：
/hotspot/src/share/vm/runtime/objectMonitor.hpp
打開看一下，會發現下面的內容：

ObjectMonitor(){
	_header			= NULL;
	_count			= 0+1-1 ;
	_waiters		= 0;
	_WaitSet		= NULL;
	//此處省略一部分...
	_owner			= NULL;
	_EntryList		= NULL;
	//...
}

當然，中間省略了很多引數，但是從上面幾個引數來看，我們很簡單就能和上面的圖聯系起來，
_header: 物件頭
_count: 記錄加鎖的次數，重入時用到
_waiters: 當前有多少thread處于wait狀態
_WaitSet: wait中的執行緒會被加入該集合
_owner: 當前哪個執行緒持有ObjectMonitor
_EntryList: 當前等待加鎖的執行緒會被加入到該集合

假設現在有兩個執行緒t1和t2，如果t1加鎖成功，則_owner = t1，且_count += 1，
當t1釋放鎖的時候，_owner = NULL，且_count -= 1，
當鎖需要重入時，會對_count進行累減到0，

3. JIT——逃逸分析

1. 逃逸分析是指JIT即時編譯器會堆代碼進行執行緒逃逸的分析，并根據分析結果進行指令優化，
2. 通常情況下，JVM的server模式編譯器默認開啟逃逸分析，(JDK8以后JVM通過hotspot實作，其中包含1個解釋器和2個編譯器，這2個編譯器就可以成為JIT，其中一個是client模式，另一個是server模式，server模式默認開啟逃逸分析，client模式相反，)
3. 可以通過設定JVM引數：-XX:-DoEscapeAnalysis關閉逃逸分析，或者設定-XX:+DoEscapeAnalysis開啟逃逸分析，

逃逸分析的作用：

1. 同步省略，如果一個物件只能被一個執行緒訪問到，那么會省去對該物件的加鎖，
2. 將堆分配轉化為堆疊分配，如果一個物件被創建后，指向該物件的指標永遠不會逃逸，那么該物件可能是堆疊分配的候選，而不是堆分配，
3. 分離物件或標量替換，. 有的物件不需要作為連續分配的記憶體存在，也能被訪問到，那么該變數的部分或者全部可以不存盤在記憶體，而是存盤在暫存器，

4. 鎖的粗化

什么是鎖的粗化：
當一個方法中有連續的加鎖操作時，多次加鎖操作將被JIT優化為一個鎖，減少了頻繁申請和釋放鎖的次數，提高了性能，
示例代碼如下：

    public static void main(String[] args) {
        synchronized (LockTest.class){
            System.out.println("111");
        }
        synchronized (LockTest.class){
            System.out.println("222");
        }
        synchronized (LockTest.class){
            System.out.println("333");
        }
    }

來查看一下位元組碼檔案：

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=5, args_size=1
         0: ldc           #2                  // class com/fujitsu/smartstore/LockTest
         2: dup
         3: astore_1
         4: monitorenter
         5: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
         8: ldc           #4                  // String 111
        10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        13: aload_1
        14: monitorexit
        15: goto          23
        18: astore_2
        19: aload_1
        20: monitorexit
        21: aload_2
        22: athrow
        23: ldc           #2                  // class com/fujitsu/smartstore/LockTest
        25: dup
        26: astore_1
        27: monitorenter
        28: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
        31: ldc           #6                  // String 222
        33: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        36: aload_1
        37: monitorexit
        38: goto          46
        41: astore_3
        42: aload_1
        43: monitorexit
        44: aload_3
        45: athrow
        46: ldc           #2                  // class com/fujitsu/smartstore/LockTest
        48: dup
        49: astore_1
        50: monitorenter
        51: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
        54: ldc           #7                  // String 333
        56: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        59: aload_1
        60: monitorexit
        61: goto          71
        64: astore        4
        66: aload_1
        67: monitorexit
        68: aload         4
        70: athrow
        71: return

指令比較多，可以ctrl + F進行搜索，我們可以找到這兩條指令：monitorenter、monitorexit，看，前面學習的syncronized原理在這里就用上了，
咱們通過看位元組碼檔案可以發現，這里的鎖并沒有被粗化成一個鎖，
那是因為我們這里查看的是javac編譯后的位元組碼檔案，而逃逸分析的優化是JIT將位元組碼檔案翻譯為機器碼檔案程序中進行的，
如果想要查看JIT編譯后的檔案，可以使用JITWatch等工具查看，此處不再贅述，

5. 鎖的消除

鎖的消除很顯而易見，當某個代碼塊使用的鎖物件只能被一個執行緒獲取到，則JIT會消除該同步操作，
如下：

    public static void main(String[] args) {
        synchronized (new Object()){
            System.out.println("111");
        }
    }

多個執行緒獲取到的鎖物件都是不同的Object物件，因此JIT進行逃逸分析時會消除該同步操作，

6. 鎖的基本知識

1. JVM分為32位和64位兩種，因此對于物件頭的存盤位數會有一定區別，但是整體邏輯相同，
2. 在jvm原始碼下的/hotspot/src/share/vm/oops/markOop.hpp檔案中有對物件頭的存盤位數進行解釋說明，比如，以32位JVM為例，前25位存盤hash code，接下來的4位存盤age，再往后的1位存盤偏向狀態，緊接著的2位存盤鎖的狀態，
3. 鎖的狀態分為4種：無鎖(01)，偏向鎖(01)，輕量級鎖(00)，重量級鎖(10)，GC標記(11)，并按照下列順序膨脹升級：
   -無鎖：25bit記錄物件hashcode，4bit存盤物件分代年齡，1bit存盤偏向狀態(0)，2bit存放鎖狀態(01)
   -偏向鎖：23bit存放執行緒id，2bit存放Epoch，4bit存放物件分代年齡，1bit存放偏向狀態(1)，2bit存放鎖狀態(01)
   -輕量級鎖：30bit存放執行緒堆疊中記錄鎖的指標，2bit存放鎖狀態(00)
   -重量鎖：30bit存放指向重量級鎖monitor的指標(依賴Mutex作業系統的互斥)，2bit存放鎖狀態(10)
   此外還有個 GC狀態：30bit置空，2bit存放鎖狀態(11)

鎖升級程序（不可逆）：
偏向鎖：減少同一個執行緒去獲取鎖的成本，在沒有競爭執行緒的情況下，當某個執行緒短時間內多次獲取到鎖后，該鎖會偏向該執行緒，Mark Word的結構會轉變為偏向鎖結構，該執行緒再次請求該鎖時，就不需要重新申請鎖了(減少了一些可能會涉及到CAS的操作)，但是當有競爭執行緒的情況下，不應該使用偏向鎖，因為每次獲取鎖的執行緒都可能不同，偏向鎖失敗后就會升級到輕量級鎖，

輕量級鎖：偏向鎖失效后會先升級為輕量級鎖（JDK1.6后加入），此時Mark Word轉換為輕量級鎖的結構，輕量級鎖提升性能的依據是：“大部分鎖在整個同步周期內都不存在競爭”，但這是經驗資料，輕量級鎖只適用于執行緒交替執行同步塊的場景，如果同一時間訪問同一個鎖的話，就會導致輕量級鎖升級為重量級鎖，

自旋鎖：輕量級鎖失效后，JVM為了避免執行緒在作業系統中真正掛起，還會采用自旋鎖的形式進行優化，這是基于在大多數情況下，執行緒持有鎖的時間都不會太長而設計的，如果執行緒直接在作業系統上掛起，就涉及到用戶態和內核態之間的切換，這個操作極度消耗時間，由于執行緒不會持有鎖太長時間，因此其他執行緒自旋中一旦獲取到鎖，就順利進入臨界區，而不需要進行用戶態到內核態的轉換了，如果CAS獲取鎖失敗達到一定次數，將升級為重量級鎖，

重量級鎖：通過作業系統Mutex互斥量將執行緒掛起，實作同步，

由于本章內容過多，所以將AQS放在下一章來學習~

一些思考：

1. 在下面代碼中，o物件存放在哪里？參考存放在哪里？元資料class存放在哪里？

    public void test(){
        Object o = new Object();
    }

2. 上述代碼中，o一定存放在堆區嗎？

下一章：Java架構師學習之路之并發編程四：Java同步器之synchronized&Lock&AQS（下）

歡迎大家一起討論，讓我們一起向著架構師前進~~~