前幾節你應該已經瞭解和掌握了Thread、ThreadLocal、Volatile這幾個併發基礎知識的底層原理。這一節，你可以跟我一起深入瞭解下synchronized關鍵字的底層原理和其涉及的基礎知識。看完這篇成長記，你可以獲取到如下幾點：
synchronized預備知識：
理解什麼是CAS？
synchronized會形成幾種鎖的型別
HotspotJVM虛擬機器Java物件記憶體中的佈局結構是什麼，markword是鎖的關鍵欄位？
作業系統中使用者態和核心態的資源操作和程序是什麼意思？
synchronized核心流程及原理：
從3個層面初步分析sychronized的核心流程和原理
好了，讓我們一起開始吧！
HelloSychronized
HelloSychronized
我們來寫一個多執行緒i++的程式，體驗一下，多執行緒如果是併發的修改一個數據，會有什麼樣的執行緒併發安全問題。
剛才說過了，volatile，解決的對一個共享資料，有人寫，有人讀，多個執行緒併發讀和寫的可見性的問題，而多個執行緒對一個共享資料併發的寫，可能會導致資料出錯，產生原子性的問題。
volatile為什麼不能保證原子性？
從JMM記憶體模型就可以看出來，多個執行緒同時修改一個變數，都是在自己本地記憶體中修改，volatile只是保證一個執行緒修改，另一個執行緒讀的時候，發起修改的執行緒是強制重新整理資料主存，過期其他執行緒的工作記憶體的快取，沒法做到多個執行緒在本地記憶體同時寫的時候，限制只能有一個執行緒修改，因為執行緒自己修改自己記憶體的資料沒有發生競爭關係。而且之後會給各自寫入主記憶體，當然就保證不了只能有一個執行緒修改主記憶體的資料，做不到原子性了。
為了解決這個問題，可以使用syncrhonized給修改這個操作加一把鎖，一旦說某個執行緒加了一把鎖之後，就會保證，其他的執行緒沒法去讀取和修改這個變數的值了，同一時間，只有一個執行緒可以讀這個資料以及修改這個資料，別的執行緒都會卡在嘗試獲取鎖那兒。這樣也就不會出現併發同時修改，資料出錯，原子性問題了。
synchronized鎖一般有兩類，一種是對某個例項物件來加鎖，另外一種是對這個類進行加鎖。相信大家很熟悉了，這裡用一個Hello synchronized的小例子，舉一個簡單物件加鎖的例子。
程式碼如下：
public class HelloSynchronized { public static void main（String［］ args） { Object o = new Object（）； synchronized （o）{ } } }
對類加鎖和對例項物件的更多例子這裡就不舉例了，我們更多的是研究synchronized它的底層原理。基本的使用相信你一定可以自己學習到。
在分析sychronized原理期間，需要不斷的補充一些基礎知識。
學習sychronized先決條件（Prerequisites）
學習sychronized先決條件（Prerequisites）
sychronized鎖的概念
在JDK 早期 sychronized 使用的時候，直接建立的重量級鎖，效能很不好。
在之後JDK新的版本中，sychronized優化了鎖，分為了4種，無鎖態、偏向鎖、自旋鎖（輕量鎖）、重量鎖，會根據情況自動升級鎖。
這四種鎖分別表示什麼意思呢？
無鎖態
表示第一次對剛建立的物件或者類加鎖時的狀態。我發現只有一個執行緒在操作程式碼塊的資源，壓根不需要加鎖。此時會處於無鎖態。
偏向鎖
，類似於貼標籤，表示這個資源暫時屬於某個執行緒，偏向它所有了。打個比方，就好比一個座位只能做一個人，你坐下後，在座位上貼上了你自己的標籤。別人發現已經有標籤了，肯定就不會在坐了。
輕量鎖（自旋鎖）：
輕量鎖，底層是CAS自旋的操作，所以也叫自旋鎖。這裡簡單普及下自旋CAS的操作流程，之後將Aotmic類的時候會仔細講下。CAS自旋流程如下：
最後我們來聊下什麼是
重量級鎖
？這又要牽扯另一個知識了。在Linux作業系統層面，由於需要限制不同的程式之間的訪問能力， 防止他們獲取別的程式的記憶體資料， 或者獲取外圍裝置的資料， 併發送到網路， CPU劃分出兩個許可權等級使用者態和核心態。用於表示程序執行時所處狀態。
你可以簡單理解，一個程式啟動後會有對應的程序，它們操作的資源分為兩種，屬於使用者態的資源或者核心態的資源。
使用者態是不能直接操作核心態中資源的，只能通知核心態來操作。這個在硬體級別也有對應的指令級別（比如Intel ring0-ring3級別的指令，ring0級別一般對應的就是使用者態程序可以操作的指令，ring3對應的是核心態程序可以發起的指令）。
如下圖所示：
這個和synchronized有什麼關係呢？因為synchronized加重量級鎖的操作，是對硬體資源的鎖指令操作，所以肯定是需要處於核心態的程序才可以操作，JVM的程序只是處於使用者態的程序，所以需要向作業系統申請，這個過程肯定會很消耗資源的。
比如，synchronized的本質是JVM使用者空間的一個程序（處於使用者態）向作業系統（核心態）發起一個lock的鎖指令操作 。
C++程式碼如下：
//Adding a lock prefix to an instruction on MP machine \#define LOCK_IF_MP（mp） “cmp $0， ” #mp “； je 1f； local； 1 ： ”
如下圖右邊所示：
sychronized鎖狀態的記錄
瞭解了sychronized的鎖的幾種型別後，怎麼標識是什麼樣的synchronized鎖呢？這個就要聊到Java的物件在JVM的記憶體中的結構了。不同虛擬機器結構略有差別，這裡講一下HotSpot虛擬機器中的物件結構：
synchronized鎖狀態的資訊就記錄在markword中。markword在64位的作業系統上，8位元組，64位大小的空間的區域。
不同的鎖的標記在如下圖所示：
這個表你不用背下來，你只要知道，synchronized的輕量鎖和重量鎖透過2位即可以區分出來，偏向鎖和無鎖需要3位。
有了上面的基礎知識後，就可以開始研究synchronized的底層原理了。
位元組碼層面的synchronized
synchronized
sychronized在Java程式碼層面就如上面Hello Synconized那個最簡單的例子所示，我們來看下它的位元組碼層面是什麼樣子的？
上面main方法的位元組碼如下：
0 new #2
new、dup、invokespecial、 astore_1這些指令是學習volatile的時候你應該很熟悉了。我這裡需要關注的是另外 2個核心的JVM指令：
monitorenter、monitorexit
。
這個表示sychronized加鎖的同步程式碼塊的進入和退出。為什麼有兩個monitorexit呢？一個是正常退出，一個丟擲異常也會退出釋放鎖。
JVM層面的synchronized
JVM層面的synchronized
那麼，當 JVM的HotSpot實現中，當遇到這兩個JVM指令，又是如何執行的呢？讓我們來看一下。
在JVM HotSpot的C++程式碼實際執行過程中，執行了一個InterpreterRuntime：： monitorenter方法，程式碼如下：
IRT_ENTRY_NO_ASYNC（void， InterpreterRuntime：：monitorenter（JavaThread* thread， BasicObjectLock* elem）） \#ifdef ASSERT thread->last_frame（）。interpreter_frame_verify_monitor（elem）； \#endif if （PrintBiasedLockingStatistics） { Atomic：：inc（BiasedLocking：：slow_path_entry_count_addr（））； } Handle h_obj（thread， elem->obj（））； assert（Universe：：heap（）->is_in_reserved_or_null（h_obj（））， “must be NULL or an object”）； if （UseBiasedLocking） { // Retry fast entry if bias is revoked to avoid unnecessary inflation ObjectSynchronizer：：fast_enter（h_obj， elem->lock（）， true， CHECK）； } else { ObjectSynchronizer：：slow_enter（h_obj， elem->lock（）， CHECK）； } assert（Universe：：heap（）->is_in_reserved_or_null（elem->obj（））， “must be NULL or an object”）； \#ifdef ASSERT thread->last_frame（）。interpreter_frame_verify_monitor（elem）； \#endif IRT_END
你可以看下上面的方法的脈絡（不懂C++也沒有關係，懂if-else就行）。它的核心有兩個if。
第一個if根據變數名字PrintBiasedLockingStatistics可以判斷出應該是列印偏向鎖的統計資訊，明顯不是最重要的。
第二個if同理，UseBiasedLocking表示了是否使用了偏向鎖，如果是呼叫了ObjectSynchronizer：：fast_enter否則
ObjectSynchronizer：：slow_enter。
很明顯，第二個if中是synchronized加鎖的核心程式碼。我們還需要繼續看下它們的脈絡。
程式碼如下：synchronizer。cpp
void ObjectSynchronizer：：fast_enter（Handle obj， BasicLock* lock， bool attempt_rebias， TRAPS） { if （UseBiasedLocking） { if （！SafepointSynchronize：：is_at_safepoint（）） { BiasedLocking：：Condition cond = BiasedLocking：：revoke_and_rebias（obj， attempt_rebias， THREAD）； if （cond == BiasedLocking：：BIAS_REVOKED_AND_REBIASED） { return； } } else { assert（！attempt_rebias， “can not rebias toward VM thread”）； BiasedLocking：：revoke_at_safepoint（obj）； } assert（！obj->mark（）->has_bias_pattern（）， “biases should be revoked by now”）； } slow_enter （obj， lock， THREAD） ； }
可以看到fast_enter方法，核心脈絡除了取消偏向和重新偏向的邏輯（從變數明和註釋可以看出來，這裡暫時不重要，先忽略），最後核心脈絡還是呼叫了slow_enter方法。讓我們來看下：
void ObjectSynchronizer：：slow_enter（Handle obj， BasicLock* lock， TRAPS） { markOop mark = obj->mark（）； assert（！mark->has_bias_pattern（）， “should not see bias pattern here”）； if （mark->is_neutral（）） { // Anticipate successful CAS —— the ST of the displaced mark must // be visible <= the ST performed by the CAS。 lock->set_displaced_header（mark）； if （mark == （markOop） Atomic：：cmpxchg_ptr（lock， obj（）->mark_addr（）， mark）） { TEVENT （slow_enter： release stacklock） ； return ； } // Fall through to inflate（） 。。。 } else if （mark->has_locker（） && THREAD->is_lock_owned（（address）mark->locker（））） { assert（lock ！= mark->locker（）， “must not re-lock the same lock”）； assert（lock ！= （BasicLock*）obj->mark（）， “don‘t relock with same BasicLock”）； lock->set_displaced_header（NULL）； return； } \#if 0 // The following optimization isn’t particularly useful。 if （mark->has_monitor（） && mark->monitor（）->is_entered（THREAD）） { lock->set_displaced_header （NULL） ； return ； } \#endif // The object header will never be displaced to this lock， // so it does not matter what the value is， except that it // must be non-zero to avoid looking like a re-entrant lock， // and must not look locked either。 lock->set_displaced_header（markOopDesc：：unused_mark（））； ObjectSynchronizer：：inflate（THREAD， obj（））->enter（THREAD）； }
上面這一段是sychronized加鎖，核心中的核心，可以發現很多有意思的地方：
1）
從註釋可以看出，鎖會有膨脹過程，物件頭會記錄鎖的相關資訊。
2）
Atomic::cmpxchg_ptr體現了ompare and exchange (CAS)操作，是輕量級鎖。
3）
mark->has_locker() && THREAD->is_lock_owned((address)mark->locker()體現了synchronized是可重入鎖
4）
最後的ObjectSynchronizer::inflate意思為膨脹為重量級鎖。
C++的程式碼有很多細節和知識，你開始學習的時候不要想著全部搞清楚，一定要有之前學到的思想，先脈絡後細節。搞清楚脈絡再說研究細節的部分。
所以，透過初步看過synchronized的HotSpot C++程式碼實現，重點的脈絡就是鎖升級的過程和原理，接下來重點分析一下這個過程。
synchronized鎖升級的過程
synchronized鎖升級的過程
前面透過從位元組碼層面到JVM層面初步瞭解了synchronized的實現，結合之前說的sychronized的鎖的幾種型別。最終可以分析出來synchronized鎖會有一個升級的過程。過程如下圖所示：
這個圖非常重要，大家一定要牢記住。下一節會花費整整一節來講在這個圖。
本文由部落格一文多發平臺 OpenWrite 釋出！
