並發編程之：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也叫互斥鎖。也就是說重量級鎖會讓鎖從用戶態切換到內核態，將執行緒的調度交給作業系統，性能相比會很低。
整個鎖升級的過程通過下面這張圖能更全面的展示。
有需要原圖的朋友，關注我的公眾號【黑子的學習筆記】後台回復「鎖升級」獲取。
好的，今天的內容就到這裡，我們下期再見。
