并發編程之：synchronized-有解無憂

大家好，我是小黑，一個在互聯網茍且偷生的農民工，

之前的文章中跟大家分享了關于Java中執行緒的一些概念和基本的使用方法，比如如何在Java中啟動一個執行緒，生產者消費者模式等，以及如果要保證并發情況下多執行緒共享資料的訪問安全，操作的原子性，使用到了synchronized關鍵字，今天主要和大家聊一聊synchronized關鍵字的用法和底層的原理，

為什么要用synchronized

相信大家對于這個問題一定都有自己的答案，這里我還是要啰嗦一下，我們來看下面這段車站售票的代碼：

/**
 * 車站開兩個視窗同時售票
 */
public class TicketDemo {

    public static void main(String[] args) {
        TrainStation station = new TrainStation();
        // 開啟兩個執行緒同時進行售票
        new Thread(station, "A").start();
        new Thread(station, "B").start();
    }
}

class TrainStation implements Runnable {
    private volatile int ticket = 10;
    @Override
    public void run() {
        while (ticket > 0) {
            System.out.println("執行緒" + Thread.currentThread().getName() + "售出" + ticket + "號票");
            ticket = ticket - 1;
        }
    }
}

上面這段代碼是沒有做考慮執行緒安全問題的，執行這段代碼可能會出現下面的運行結果：

可以看出，兩個執行緒都買出了10號票，這在實際業務場景中是絕對不能出現的，（你去坐火車有個大哥說你占了他的座，讓你滾，還說你是票販子，你氣不氣）

那因為有這種問題的存在，我們應該怎么解決呢？synchronized就是為了解決這種多執行緒共享資料安全問題的，

使用方式

synchronized的使用方式主要以下三種，

同步代碼塊

public static void main(String[] args) {
    String str = "hello world";
    synchronized (str) {
        System.out.println(str);
    }
}

同步實體方法

class TrainStation implements Runnable {
    private volatile int ticket = 100;

    // 關鍵字直接寫在實體方法簽名上
    public synchronized void sale() { 
        while (ticket > 0) {
            System.out.println("執行緒" + Thread.currentThread().getName() + "售出" + ticket + "號票");
            ticket = ticket - 1;
        }
    }

    @Override
    public void run() {
        sale();
    }
}

同步靜態方法

class TrainStation implements Runnable {
    // 注意這里ticket變數宣告為static的，因為靜態方法只能訪問靜態變數
    private volatile static int ticket = 100;

    // 也可以直接放在靜態方法的簽名上
    public static synchronized void sale() {
        while (ticket > 0) {
            System.out.println("執行緒" + Thread.currentThread().getName() + "售出" + ticket + "號票");
            ticket = ticket - 1;
        }
    }
    @Override
    public void run() {
        sale();
    }
}

位元組碼語意

通程序式運行，我們發現通過synchronized關鍵字確實可以保證執行緒安全，那計算機到底是怎么保證的呢？這個關鍵字背后到底做了些什么？我們可以看一下java代碼編譯后的class檔案，首先來看同步代碼塊編譯后的class，通過javap -v 名稱可以查看位元組碼檔案：

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: ldc           #2                  // String hello world
         2: astore_1
         3: aload_1
         4: dup
         5: astore_2
         6: monitorenter			// 監視器進入
         7: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
        10: aload_1
        11: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        14: aload_2
        15: monitorexit				// 監視器退出
        16: goto          24
        19: astore_3
        20: aload_2
        21: monitorexit
        22: aload_3
        23: athrow
        24: return

注意看第6行和第15行，這兩個指令是增加synchronized代碼塊之后才會出現的，monitor是一個物件的監視器，monitorenter代表這段指令的執行要先拿到物件的監視器之后，才能接著往下執行，而monitorexit代表執行完synchronized代碼塊之后要從物件監視器中退出，也就是要釋放，所以這個物件監視器也就是我們所說的鎖，獲取鎖就是獲取這個物件監視器的所有權，

接下來我們在看看synchronized修飾實體方法時的位元組碼檔案是什么樣的，

 public synchronized void sale();
    descriptor: ()V
	//方法標識ACC_PUBLIC代表public修飾，ACC_SYNCHRONIZED指明該方法為同步方法
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED 
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: getfield      #2                  // Field ticket:I
	// 省略其他無關位元組碼

可以看到synchronized修飾實體方法上之后不會再有monitorenter和monitorexit指令，而是直接在這個方法上增加一個ACC_SYNCHRONIZED的flag，當程式在運行時，呼叫sale()方法時，會檢查該方法是否有ACC_SYNCHRONIZED訪問標識，如果有，則表明該方法是同步方法，這時候還行執行緒會先嘗試去獲取該方法對應的監視器（monitor）物件，如果獲取成功，則繼續執行該sale()方法，在執行期間，任何其他執行緒都不能再獲取該方法監視器的使用權，知道該方法執行完畢或者拋出例外，才會釋放，其他執行緒可以重新獲得該監視器，

那么synchronized修飾靜態方法的位元組碼檔案是什么樣呢？

public static synchronized void sale();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=3, locals=0, args_size=0
         0: getstatic     #2                  // Field ticket:I
      // 省略其他無關位元組碼

可以看出synchronized修飾靜態方法和實體方法沒有區別，都是增加一個ACC_SYNCHRONIZED的flag，靜態方法只是比實體方法多一個ACC_STATIC標識代表這個方法是靜態的，

以上的同步代碼塊，同步方法中都提到物件監視器這個概念，那么三種同步方式使用的物件監視器具體是哪個物件呢？

同步代碼塊的物件監視器就是使用的我們synchronized(str)中的str,也就是我們括號中指定的物件，而我們在開發中增加同步代碼塊的目的是為了多個執行緒同一時間只能有一個執行緒持有監視器，所以這個物件的指定一定要是多個執行緒共享的物件，不能直接在括號中new一個物件，這樣不能做到互斥，也就不能保證安全，

同步實體方法的物件監視器是當前這個實體，也就是this，

同步靜態方法的物件監視器是當前這個靜態方法所在類的Class物件，我們都知道Java中每個類在運行程序中也會用一個物件表示，就是這個類的物件，每個類有且僅有一個，

物件鎖（monitor）

上面說了執行緒要進入同步代碼塊需要先獲取到物件監視器，也就是物件鎖，那在開始說之前我們先來了解下在Java中一個物件都由哪些東西組成，

這里先問大家一個問題，Object obj = new Object()這段代碼在JVM中是怎樣的一個記憶體分布？

想必了解過JVM知識的同學應該都知道，new Object()會在堆記憶體中創建一個物件，Object obj是堆疊記憶體中的一個參考，這個參考指向堆中的物件，那么怎么知道堆記憶體中的物件到底由哪些內容組成呢？這里給大家介紹一個工具叫JOL(Java Object Layout)Java物件布局，可以通過maven在專案中直接引入，

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>

引入之后在代碼中可以列印出物件的記憶體分布，

public static void main(String[] args) {
    Object obj = new Object();
    // parseInstance將物件決議，toPrintable讓決議后的結果可輸出
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
}

輸出后的結果如下：

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

從結果上可以看出，這個obj物件主要分4部分，每部分的SIZE=4代表4個位元組，前三行是物件頭object header，最后一行的4個位元組是為了保證一個物件的大小能是8的整數倍，

我們再來看看對于一個加了鎖的物件，列印出來有什么不一樣？

public static void main(String[] args) {
    Object obj = new Object();
    synchronized (obj){
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           58 f7 19 01 (01011000 11110111 00011001 00000001) (18478936)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

可以很明顯的看到，最前面的8個位元組發生了變化，也就是Mark Word變了，所以給物件加鎖，實際就是改變物件的Mark Word，

Mark Word中的這8個位元組具有不同的含義，為了讓這64個bit能表示更多資訊，JVM將最后2位設定為標記位，不同標記位下的Mark word含義如下：

|------------------------------------------------------------------------------|--------------------|
|                                  Mark Word (64 bits)                         |       State        |
|------------------------------------------------------------------------------|--------------------|
| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |       無鎖態        |
|------------------------------------------------------------------------------|--------------------|
| thread:54 |       epoch:2        | unused:1 | age:4 | biased_lock:1 | lock:2 |       偏向鎖        |
|------------------------------------------------------------------------------|--------------------|
|                       ptr_to_lock_record:62                         | lock:2 |      輕量級鎖        |
|------------------------------------------------------------------------------|--------------------|
|                     ptr_to_heavyweight_monitor:62                   | lock:2 |      重量級鎖        |
|------------------------------------------------------------------------------|--------------------|
|                                                                     | lock:2 |       GC標記        |
|------------------------------------------------------------------------------|--------------------|

其中最后兩位的鎖標記位，不同值代表不同含義，

biased_lock	lock	狀態
0	00	無鎖態(NEW)
0	01	偏向鎖
1	01	偏向鎖
0	00	輕量級鎖
0	10	重量級鎖
0	11	GC標記

biased_lock標記該物件是否啟用偏向鎖，1代表啟用偏向鎖，0代表未啟用，

age：4位的Java物件年齡，在GC中，如果物件在Survivor區復制一次，年齡增加1，當物件達到設定的閾值時，將會晉升到老年代，默認情況下，并行GC的年齡閾值為15，并發GC的年齡閾值為6，由于age只有4位，所以最大值為15，這就是-XX:MaxTenuringThreshold選項最大值為15的原因，

identity_hashcode：25位的物件標識Hash碼，采用延遲加載技術，呼叫方法System.identityHashCode()計算，并會將結果寫到該物件頭中，當物件被鎖定時，該值會移動到管程Monitor中，

thread：持有偏向鎖的執行緒ID，

epoch：偏向時間戳，

ptr_to_lock_record：指向堆疊中鎖記錄的指標，

ptr_to_heavyweight_monitor：指向管程Monitor的指標，

鎖升級程序

既然會有無鎖，偏向鎖，輕量級鎖，重量級鎖，那么這些鎖是怎么樣一個升級程序呢，我們來看一下，

新建

從前面講到物件頭的結構和我們上面列印出來的物件記憶體分布，可以看出新創建的一個物件，它的標記位是00，偏向鎖標記(biased_lock)也是0，表示該物件是無鎖態，

偏向鎖

偏向鎖是指當一段同步代碼被同一個執行緒所訪問時，不存在其他執行緒的競爭時，那么該執行緒在以后訪問時便會自動獲得鎖，從而降低獲取鎖帶來的消耗，提高性能，

當一個執行緒訪問同步代碼塊并獲取鎖時，會在 Mark Word 里存盤執行緒 ID，在執行緒進入和退出同步塊時不再通過 CAS 操作來加鎖和解鎖，而是檢測 Mark Word 里是否存盤著指向當前執行緒的偏向鎖，輕量級鎖的獲取及釋放依賴多次 CAS 原子指令，而偏向鎖只需要在置換 ThreadID 的時候依賴一次 CAS 原子指令即可，

輕量級鎖

輕量級鎖是指當鎖是偏向鎖的時候，有其他執行緒來競爭，但是該鎖正在被其他執行緒訪問，那么就會升級為輕量級鎖，或者還有一種情況就是關閉JVM的偏向鎖開關，那么一開始鎖物件就會被標記位輕量級鎖，

輕量級鎖考慮的是競爭鎖物件的執行緒不多，而且執行緒持有鎖的時間也不長的情景，因為阻塞執行緒需要CPU從用戶態轉到內核態，代價較大，如果剛剛阻塞不久這個鎖就被釋放了，那這個代價就有點得不償失了，因此這個時候就干脆不阻塞這個執行緒，讓它自旋這等待鎖釋放，

在進入同步代碼時，如果物件鎖狀態符合升級輕量級鎖的條件，虛擬機會在當前想要競爭鎖的執行緒的堆疊幀中開辟一個Lock Record空間，并將鎖物件的Mark Word拷貝到Lock Record空間中，

然后虛擬機會使用CAS操作嘗試將物件的Mark Word更新為指向Lock Record的指標，并將Lock Record中的owner指標指向物件的Mark Word，

如果操作成功，則表示當前執行緒獲得鎖，如果失敗則表示其他執行緒持有該鎖，當前執行緒會嘗試使用自旋的方式來重新獲取，

輕量級鎖解鎖時，會使用CAS操作將Lock Record替換回到物件頭，如果成功，則表示沒有競爭發生，如果失敗，表示當前鎖存在競爭，鎖就會膨脹成重量級鎖，

重量級鎖

重量級鎖是指當有一個執行緒獲取鎖之后，其余所有等待獲取該鎖的執行緒都會處于阻塞狀態，是依賴于底層作業系統的Mutex實作，Mutex也叫互斥鎖，也就是說重量級鎖會讓鎖從用戶態切換到內核態，將執行緒的調度交給作業系統，性能相比會很低，

整個鎖升級的程序通過下面這張圖能更全面的展示，

有需要原圖的朋友，關注我的公眾號【黑子的學習筆記】后臺回復“鎖升級”獲取，

好的，今天的內容就到這里，我們下期再見，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/295977.html

標籤：Java

上一篇：Elastic Job 同城主備、同城雙活，高可用必備～

下一篇：【軟體工程】藥品存銷資訊管理系統