Java中的鎖 Lock和synchronized

• 2019 年 10 月 7 日
• 筆記

Java中的鎖機制及Lock類

鎖的釋放-獲取建立的happens before 關係

鎖是java並發編程中最重要的同步機制。鎖除了讓臨界區互斥執行外，還可以讓釋放鎖的執行緒向獲取同一個鎖的執行緒發送消息。

下面是鎖釋放-獲取的示例程式碼：

class MonitorExample {  int a = 0;public synchronized void writer() {  //1  a++;                             //2  }                                    //3public synchronized void reader() {  //4  int i = a;                       //5  ……  }                                    //6  }

假設執行緒A執行writer()方法，隨後執行緒B執行reader()方法。根據happens before規則，這個過程包含的happens before 關係可以分為兩類：

1. 根據程式次序規則，1 happens before 2, 2 happens before 3; 4 happens before 5, 5 happens before 6。
2. 根據監視器鎖規則，3 happens before 4。
3. 根據happens before 的傳遞性，2 happens before 5。

上述happens before 關係的圖形化表現形式如下：

在上圖中，每一個箭頭鏈接的兩個節點，代表了一個happens before 關係。黑色箭頭表示程式順序規則；橙色箭頭表示監視器鎖規則；藍色箭頭表示組合這些規則後提供的happens before保證。

上圖表示在執行緒A釋放了鎖之後，隨後執行緒B獲取同一個鎖。在上圖中，2 happens before 5。因此，執行緒A在釋放鎖之前所有可見的共享變數，在執行緒B獲取同一個鎖之後，將立刻變得對B執行緒可見。

鎖釋放和獲取的記憶體語義

當執行緒釋放鎖時，JMM會把該執行緒對應的本地記憶體中的共享變數刷新到主記憶體中。以上面的MonitorExample程式為例，A執行緒釋放鎖後，共享數據的狀態示意圖如下：

當執行緒獲取鎖時，JMM會把該執行緒對應的本地記憶體置為無效。從而使得被監視器保護的臨界區程式碼必須要從主記憶體中去讀取共享變數。下面是鎖獲取的狀態示意圖：

對比鎖釋放-獲取的記憶體語義與volatile寫-讀的記憶體語義，可以看出：鎖釋放與volatile寫有相同的記憶體語義；鎖獲取與volatile讀有相同的記憶體語義。

下面對鎖釋放和鎖獲取的記憶體語義做個總結：

• 執行緒A釋放一個鎖，實質上是執行緒A向接下來將要獲取這個鎖的某個執行緒發出了（執行緒A對共享變數所做修改的）消息。
• 執行緒B獲取一個鎖，實質上是執行緒B接收了之前某個執行緒發出的（在釋放這個鎖之前對共享變數所做修改的）消息。
• 執行緒A釋放鎖，隨後執行緒B獲取這個鎖，這個過程實質上是執行緒A通過主記憶體向執行緒B發送消息。

鎖記憶體語義的實現

本文將藉助ReentrantLock的源程式碼，來分析鎖記憶體語義的具體實現機制。

請看下面的示例程式碼：

class ReentrantLockExample {  int a = 0;  ReentrantLock lock = new ReentrantLock();public void writer() {  lock.lock();         //獲取鎖  try {  a++;  } finally {  lock.unlock();  //釋放鎖  }  }public void reader () {  lock.lock();        //獲取鎖  try {  int i = a;  ……  } finally {  lock.unlock();  //釋放鎖  }  }  }

在ReentrantLock中，調用lock()方法獲取鎖；調用unlock()方法釋放鎖。

ReentrantLock的實現依賴於java同步器框架AbstractQueuedSynchronizer（本文簡稱之為AQS）。AQS使用一個整型的volatile變數（命名為state）來維護同步狀態，馬上我們會看到，這個volatile變數是ReentrantLock記憶體語義實現的關鍵。 下面是ReentrantLock的類圖（僅畫出與本文相關的部分）：

ReentrantLock分為公平鎖和非公平鎖，我們首先分析公平鎖。

使用公平鎖時，加鎖方法lock()的方法調用軌跡如下：

1. ReentrantLock : lock()
2. FairSync : lock()
3. AbstractQueuedSynchronizer : acquire(int arg)
4. ReentrantLock : tryAcquire(int acquires)

在第4步真正開始加鎖，下面是該方法的源程式碼：

protected final boolean tryAcquire(int acquires) {  final Thread current = Thread.currentThread();  int c = getState();   //獲取鎖的開始，首先讀volatile變數state  if (c == 0) {  if (isFirst(current) &&  compareAndSetState(0, acquires)) {  setExclusiveOwnerThread(current);  return true;  }  }  else if (current == getExclusiveOwnerThread()) {  int nextc = c + acquires;  if (nextc < 0)  throw new Error("Maximum lock count exceeded");  setState(nextc);  return true;  }  return false;  }

從上面源程式碼中我們可以看出，加鎖方法首先讀volatile變數state。

在使用公平鎖時，解鎖方法unlock()的方法調用軌跡如下：

1. ReentrantLock : unlock()
2. AbstractQueuedSynchronizer : release(int arg)
3. Sync : tryRelease(int releases)

在第3步真正開始釋放鎖，下面是該方法的源程式碼：

protected final boolean tryRelease(int releases) {  int c = getState() - releases;  if (Thread.currentThread() != getExclusiveOwnerThread())  throw new IllegalMonitorStateException();  boolean free = false;  if (c == 0) {  free = true;  setExclusiveOwnerThread(null);  }  setState(c);           //釋放鎖的最後，寫volatile變數state  return free;  }

從上面的源程式碼我們可以看出，在釋放鎖的最後寫volatile變數state。

公平鎖在釋放鎖的最後寫volatile變數state；在獲取鎖時首先讀這個volatile變數。根據volatile的happens-before規則，釋放鎖的執行緒在寫volatile變數之前可見的共享變數，在獲取鎖的執行緒讀取同一個volatile變數後將立即變的對獲取鎖的執行緒可見。

現在我們分析非公平鎖的記憶體語義的實現。

非公平鎖的釋放和公平鎖完全一樣，所以這裡僅僅分析非公平鎖的獲取。

使用公平鎖時，加鎖方法lock()的方法調用軌跡如下：

1. ReentrantLock : lock()
2. NonfairSync : lock()
3. AbstractQueuedSynchronizer : compareAndSetState(int expect, int update)

在第3步真正開始加鎖，下面是該方法的源程式碼：

protected final boolean compareAndSetState(int expect, int update) {  return unsafe.compareAndSwapInt(this, stateOffset, expect, update);  }

該方法以原子操作的方式更新state變數，本文把java的compareAndSet()方法調用簡稱為CAS。JDK文檔對該方法的說明如下：如果當前狀態值等於預期值，則以原子方式將同步狀態設置為給定的更新值。此操作具有 volatile 讀和寫的記憶體語義。

這裡我們分別從編譯器和處理器的角度來分析,CAS如何同時具有volatile讀和volatile寫的記憶體語義。

前文我們提到過，編譯器不會對volatile讀與volatile讀後面的任意記憶體操作重排序；編譯器不會對volatile寫與volatile寫前面的任意記憶體操作重排序。組合這兩個條件，意味著為了同時實現volatile讀和volatile寫的記憶體語義，編譯器不能對CAS與CAS前面和後面的任意記憶體操作重排序。

下面我們來分析在常見的intel x86處理器中，CAS是如何同時具有volatile讀和volatile寫的記憶體語義的。

下面是sun.misc.Unsafe類的compareAndSwapInt()方法的源程式碼：

public final native boolean compareAndSwapInt(Object o, long offset,  int expected,  int x);

可以看到這是個本地方法調用。這個本地方法在openjdk中依次調用的c++程式碼為：unsafe.cpp，atomic.cpp和atomicwindowsx86.inline.hpp。這個本地方法的最終實現在openjdk的如下位置：openjdk-7-fcs-src-b147-27jun2011openjdkhotspotsrcoscpuwindowsx86vm atomicwindowsx86.inline.hpp（對應於windows作業系統，X86處理器）。下面是對應於intel x86處理器的源程式碼的片段：

// Adding a lock prefix to an instruction on MP machine  // VC++ doesn't like the lock prefix to be on a single line  // so we can't insert a label after the lock prefix.  // By emitting a lock prefix, we can define a label after it.  #define LOCK_IF_MP(mp) __asm cmp mp, 0    __asm je L0        __asm _emit 0xF0   __asm L0:inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {  // alternative for InterlockedCompareExchange  int mp = os::is_MP();  __asm {  mov edx, dest  mov ecx, exchange_value  mov eax, compare_value  LOCK_IF_MP(mp)  cmpxchg dword ptr [edx], ecx  }  }

如上面源程式碼所示，程式會根據當前處理器的類型來決定是否為cmpxchg指令添加lock前綴。如果程式是在多處理器上運行，就為cmpxchg指令加上lock前綴（lock cmpxchg）。反之，如果程式是在單處理器上運行，就省略lock前綴（單處理器自身會維護單處理器內的順序一致性，不需要lock前綴提供的記憶體屏障效果）。

intel的手冊對lock前綴的說明如下：

1. 確保對記憶體的讀-改-寫操作原子執行。在Pentium及Pentium之前的處理器中，帶有lock前綴的指令在執行期間會鎖住匯流排，使得其他處理器暫時無法通過匯流排訪問記憶體。很顯然，這會帶來昂貴的開銷。從Pentium 4，Intel Xeon及P6處理器開始，intel在原有匯流排鎖的基礎上做了一個很有意義的優化：如果要訪問的記憶體區域（area of memory）在lock前綴指令執行期間已經在處理器內部的快取中被鎖定（即包含該記憶體區域的快取行當前處於獨佔或以修改狀態），並且該記憶體區域被完全包含在單個快取行（cache line）中，那麼處理器將直接執行該指令。由於在指令執行期間該快取行會一直被鎖定，其它處理器無法讀/寫該指令要訪問的記憶體區域，因此能保證指令執行的原子性。這個操作過程叫做快取鎖定（cache locking），快取鎖定將大大降低lock前綴指令的執行開銷，但是當多處理器之間的競爭程度很高或者指令訪問的記憶體地址未對齊時，仍然會鎖住匯流排。
2. 禁止該指令與之前和之後的讀和寫指令重排序。
3. 把寫緩衝區中的所有數據刷新到記憶體中。

上面的第2點和第3點所具有的記憶體屏障效果，足以同時實現volatile讀和volatile寫的記憶體語義。

經過上面的這些分析，現在我們終於能明白為什麼JDK文檔說CAS同時具有volatile讀和volatile寫的記憶體語義了。

現在對公平鎖和非公平鎖的記憶體語義做個總結：

• 公平鎖和非公平鎖釋放時，最後都要寫一個volatile變數state。
• 公平鎖獲取時，首先會去讀這個volatile變數。
• 非公平鎖獲取時，首先會用CAS更新這個volatile變數,這個操作同時具有volatile讀和volatile寫的記憶體語義。

從本文對ReentrantLock的分析可以看出，鎖釋放-獲取的記憶體語義的實現至少有下面兩種方式：

1. 利用volatile變數的寫-讀所具有的記憶體語義。
2. 利用CAS所附帶的volatile讀和volatile寫的記憶體語義。

concurrent包的實現

由於java的CAS同時具有 volatile 讀和volatile寫的記憶體語義，因此Java執行緒之間的通訊現在有了下面四種方式：

1. A執行緒寫volatile變數，隨後B執行緒讀這個volatile變數。
2. A執行緒寫volatile變數，隨後B執行緒用CAS更新這個volatile變數。
3. A執行緒用CAS更新一個volatile變數，隨後B執行緒用CAS更新這個volatile變數。
4. A執行緒用CAS更新一個volatile變數，隨後B執行緒讀這個volatile變數。

Java的CAS會使用現代處理器上提供的高效機器級別原子指令，這些原子指令以原子方式對記憶體執行讀-改-寫操作，這是在多處理器中實現同步的關鍵（從本質上來說，能夠支援原子性讀-改-寫指令的電腦器，是順序計算圖靈機的非同步等價機器，因此任何現代的多處理器都會去支援某種能對記憶體執行原子性讀-改-寫操作的原子指令）。同時，volatile變數的讀/寫和CAS可以實現執行緒之間的通訊。把這些特性整合在一起，就形成了整個concurrent包得以實現的基石。如果我們仔細分析concurrent包的源程式碼實現，會發現一個通用化的實現模式：

1. 首先，聲明共享變數為volatile；
2. 然後，使用CAS的原子條件更新來實現執行緒之間的同步；
3. 同時，配合以volatile的讀/寫和CAS所具有的volatile讀和寫的記憶體語義來實現執行緒之間的通訊。

AQS，非阻塞數據結構和原子變數類（java.util.concurrent.atomic包中的類），這些concurrent包中的基礎類都是使用這種模式來實現的，而concurrent包中的高層類又是依賴於這些基礎類來實現的。從整體來看，concurrent包的實現示意圖如下：

synchronized實現原理

記得剛剛開始學習Java的時候，一遇到多執行緒情況就是synchronized，相對於當時的我們來說synchronized是這麼的神奇而又強大，那個時候我們賦予它一個名字「同步」，也成為了我們解決多執行緒情況的百試不爽的良藥。但是，隨著我們學習的進行我們知道synchronized是一個重量級鎖，相對於Lock，它會顯得那麼笨重，以至於我們認為它不是那麼的高效而慢慢摒棄它。 誠然，隨著Javs SE 1.6對synchronized進行的各種優化後，synchronized並不會顯得那麼重了。下面跟隨LZ一起來探索synchronized的實現機制、Java是如何對它進行了優化、鎖優化機制、鎖的存儲結構和升級過程；

實現原理

synchronized可以保證方法或者程式碼塊在運行時，同一時刻只有一個方法可以進入到臨界區，同時它還可以保證共享變數的記憶體可見性

Java中每一個對象都可以作為鎖，這是synchronized實現同步的基礎：

1. 普通同步方法，鎖是當前實例對象
2. 靜態同步方法，鎖是當前類的class對象
3. 同步方法塊，鎖是括弧裡面的對象

當一個執行緒訪問同步程式碼塊時，它首先是需要得到鎖才能執行同步程式碼，當退出或者拋出異常時必須要釋放鎖，那麼它是如何來實現這個機制的呢？我們先看一段簡單的程式碼：

public  class  SynchronizedTest  {  public  synchronized  void test1(){  }  public  void test2(){  synchronized  (this){  }  }  }

利用javap工具查看生成的class文件資訊來分析Synchronized的實現

從上面可以看出，同步程式碼塊是使用monitorenter和monitorexit指令實現的，同步方法（在這看不出來需要看JVM底層實現）依靠的是方法修飾符上的ACCSYNCHRONIZED實現。 同步程式碼塊：monitorenter指令插入到同步程式碼塊的開始位置，monitorexit指令插入到同步程式碼塊的結束位置，JVM需要保證每一個monitorenter都有一個monitorexit與之相對應。任何對象都有一個monitor與之相關聯，當且一個monitor被持有之後，他將處於鎖定狀態。執行緒執行到monitorenter指令時，將會嘗試獲取對象所對應的monitor所有權，即嘗試獲取對象的鎖； 同步方法：synchronized方法則會被翻譯成普通的方法調用和返回指令如:invokevirtual、areturn指令，在VM位元組碼層面並沒有任何特別的指令來實現被synchronized修飾的方法，而是在Class文件的方法表中將該方法的accessflags欄位中的synchronized標誌位置1，表示該方法是同步方法並使用調用該方法的對象或該方法所屬的Class在JVM的內部對象表示Klass做為鎖對象。(摘自：http://www.cnblogs.com/javaminer/p/3889023.html)

下面我們來繼續分析，但是在深入之前我們需要了解兩個重要的概念：Java對象頭，Monitor。

Java對象頭、monitor

Java對象頭和monitor是實現synchronized的基礎！下面就這兩個概念來做詳細介紹。

Java對象頭

synchronized用的鎖是存在Java對象頭裡的，那麼什麼是Java對象頭呢？Hotspot虛擬機的對象頭主要包括兩部分數據：Mark Word（標記欄位）、Klass Pointer（類型指針）。其中Klass Point是是對象指向它的類元數據的指針，虛擬機通過這個指針來確定這個對象是哪個類的實例，Mark Word用於存儲對象自身的運行時數據，它是實現輕量級鎖和偏向鎖的關鍵，所以下面將重點闡述

Mark Word。 Mark Word用於存儲對象自身的運行時數據，如哈希碼（HashCode）、GC分代年齡、鎖狀態標誌、執行緒持有的鎖、偏向執行緒 ID、偏向時間戳等等。Java對象頭一般佔有兩個機器碼（在32位虛擬機中，1個機器碼等於4位元組，也就是32bit），但是如果對象是數組類型，則需要三個機器碼，因為JVM虛擬機可以通過Java對象的元數據資訊確定Java對象的大小，但是無法從數組的元數據來確認數組的大小，所以用一塊來記錄數組長度。下圖是Java對象頭的存儲結構（32位虛擬機）：

對象頭資訊是與對象自身定義的數據無關的額外存儲成本，但是考慮到虛擬機的空間效率，Mark Word被設計成一個非固定的數據結構以便在極小的空間記憶體存儲盡量多的數據，它會根據對象的狀態復用自己的存儲空間，也就是說，Mark Word會隨著程式的運行發生變化，變化狀態如下（32位虛擬機）：

簡單介紹了Java對象頭，我們下面再看Monitor。

Monitor

什麼是Monitor？我們可以把它理解為一個同步工具，也可以描述為一種同步機制，它通常被描述為一個對象。 與一切皆對象一樣，所有的Java對象是天生的Monitor，每一個Java對象都有成為Monitor的潛質，因為在Java的設計中 ，每一個Java對象自打娘胎里出來就帶了一把看不見的鎖，它叫做內部鎖或者Monitor鎖。 Monitor 是執行緒私有的數據結構，每一個執行緒都有一個可用monitor record列表，同時還有一個全局的可用列表。每一個被鎖住的對象都會和一個monitor關聯（對象頭的MarkWord中的LockWord指向monitor的起始地址），同時monitor中有一個Owner欄位存放擁有該鎖的執行緒的唯一標識，表示該鎖被這個執行緒佔用。其結構如下：

Owner：初始時為NULL表示當前沒有任何執行緒擁有該monitor record，當執行緒成功擁有該鎖後保存執行緒唯一標識，當鎖被釋放時又設置為NULL； EntryQ:關聯一個系統互斥鎖（semaphore），阻塞所有試圖鎖住monitor record失敗的執行緒。 RcThis:表示blocked或waiting在該monitor record上的所有執行緒的個數。 Nest:用來實現重入鎖的計數。 HashCode:保存從對象頭拷貝過來的HashCode值（可能還包含GC age）。 Candidate:用來避免不必要的阻塞或等待執行緒喚醒，因為每一次只有一個執行緒能夠成功擁有鎖，如果每次前一個釋放鎖的執行緒喚醒所有正在阻塞或等待的執行緒，會引起不必要的上下文切換（從阻塞到就緒然後因為競爭鎖失敗又被阻塞）從而導致性能嚴重下降。Candidate只有兩種可能的值0表示沒有需要喚醒的執行緒1表示要喚醒一個繼任執行緒來競爭鎖。 摘自：Java中synchronized的實現原理與應用） 我們知道synchronized是重量級鎖，效率不怎麼滴，同時這個觀念也一直存在我們腦海里，不過在jdk 1.6中對synchronize的實現進行了各種優化，使得它顯得不是那麼重了，那麼JVM採用了那些優化手段呢？

鎖優化

jdk1.6對鎖的實現引入了大量的優化，如自旋鎖、適應性自旋鎖、鎖消除、鎖粗化、偏向鎖、輕量級鎖等技術來減少鎖操作的開銷。 鎖主要存在四中狀態，依次是：無鎖狀態、偏向鎖狀態、輕量級鎖狀態、重量級鎖狀態，他們會隨著競爭的激烈而逐漸升級。注意鎖可以升級不可降級，這種策略是為了提高獲得鎖和釋放鎖的效率。

自旋鎖

執行緒的阻塞和喚醒需要CPU從用戶態轉為核心態，頻繁的阻塞和喚醒對CPU來說是一件負擔很重的工作，勢必會給系統的並發性能帶來很大的壓力。同時我們發現在許多應用上面，對象鎖的鎖狀態只會持續很短一段時間，為了這一段很短的時間頻繁地阻塞和喚醒執行緒是非常不值得的。所以引入自旋鎖。 何謂自旋鎖？ 所謂自旋鎖，就是讓該執行緒等待一段時間，不會被立即掛起，看持有鎖的執行緒是否會很快釋放鎖。怎麼等待呢？執行一段無意義的循環即可（自旋）。 自旋等待不能替代阻塞，先不說對處理器數量的要求（多核，貌似現在沒有單核的處理器了），雖然它可以避免執行緒切換帶來的開銷，但是它佔用了處理器的時間。如果持有鎖的執行緒很快就釋放了鎖，那麼自旋的效率就非常好，反之，自旋的執行緒就會白白消耗掉處理的資源，它不會做任何有意義的工作，典型的占著茅坑不拉屎，這樣反而會帶來性能上的浪費。所以說，自旋等待的時間（自旋的次數）必須要有一個限度，如果自旋超過了定義的時間仍然沒有獲取到鎖，則應該被掛起。 自旋鎖在JDK 1.4.2中引入，默認關閉，但是可以使用-XX:+UseSpinning開開啟，在JDK1.6中默認開啟。同時自旋的默認次數為10次，可以通過參數-XX:PreBlockSpin來調整； 如果通過參數-XX:preBlockSpin來調整自旋鎖的自旋次數，會帶來諸多不便。假如我將參數調整為10，但是系統很多執行緒都是等你剛剛退出的時候就釋放了鎖（假如你多自旋一兩次就可以獲取鎖），你是不是很尷尬。於是JDK1.6引入自適應的自旋鎖，讓虛擬機會變得越來越聰明。

適應自旋鎖

JDK 1.6引入了更加聰明的自旋鎖，即自適應自旋鎖。所謂自適應就意味著自旋的次數不再是固定的，它是由前一次在同一個鎖上的自旋時間及鎖的擁有者的狀態來決定。它怎麼做呢？執行緒如果自旋成功了，那麼下次自旋的次數會更加多，因為虛擬機認為既然上次成功了，那麼此次自旋也很有可能會再次成功，那麼它就會允許自旋等待持續的次數更多。反之，如果對於某個鎖，很少有自旋能夠成功的，那麼在以後要或者這個鎖的時候自旋的次數會減少甚至省略掉自旋過程，以免浪費處理器資源。 有了自適應自旋鎖，隨著程式運行和性能監控資訊的不斷完善，虛擬機對程式鎖的狀況預測會越來越準確，虛擬機會變得越來越聰明。

鎖消除

為了保證數據的完整性，我們在進行操作時需要對這部分操作進行同步控制，但是在有些情況下，JVM檢測到不可能存在共享數據競爭，這是JVM會對這些同步鎖進行鎖消除。鎖消除的依據是逃逸分析的數據支援。 如果不存在競爭，為什麼還需要加鎖呢？所以鎖消除可以節省毫無意義的請求鎖的時間。變數是否逃逸，對於虛擬機來說需要使用數據流分析來確定，但是對於我們程式設計師來說這還不清楚么？我們會在明明知道不存在數據競爭的程式碼塊前加上同步嗎？但是有時候程式並不是我們所想的那樣？我們雖然沒有顯示使用鎖，但是我們在使用一些JDK的內置API時，如StringBuffer、Vector、HashTable等，這個時候會存在隱形的加鎖操作。比如StringBuffer的append()方法，Vector的add()方法：

  public  void vectorTest(){  Vectorvector =  new  Vector();  for(int i =  0  ; i <  10  ; i++){ vector.add(i +  "");  }  System.out.println(vector);  }

在運行這段程式碼時，JVM可以明顯檢測到變數vector沒有逃逸出方法vectorTest()之外，所以JVM可以大膽地將vector內部的加鎖操作消除。

鎖粗化

我們知道在使用同步鎖的時候，需要讓同步塊的作用範圍儘可能小—僅在共享數據的實際作用域中才進行同步，這樣做的目的是為了使需要同步的操作數量儘可能縮小，如果存在鎖競爭，那麼等待鎖的執行緒也能儘快拿到鎖。 在大多數的情況下，上述觀點是正確的，LZ也一直堅持著這個觀點。但是如果一系列的連續加鎖解鎖操作，可能會導致不必要的性能損耗，所以引入鎖粗話的概念。 鎖粗話概念比較好理解，就是將多個連續的加鎖、解鎖操作連接在一起，擴展成一個範圍更大的鎖。如上面實例：vector每次add的時候都需要加鎖操作，JVM檢測到對同一個對象（vector）連續加鎖、解鎖操作，會合併一個更大範圍的加鎖、解鎖操作，即加鎖解鎖操作會移到for循環之外。

輕量級鎖

引入輕量級鎖的主要目的是在多沒有多執行緒競爭的前提下，減少傳統的重量級鎖使用作業系統互斥量產生的性能消耗。當關閉偏向鎖功能或者多個執行緒競爭偏向鎖導致偏向鎖升級為輕量級鎖，則會嘗試獲取輕量級鎖，其步驟如下： 獲取鎖

1. 判斷當前對象是否處於無鎖狀態（hashcode、0、01），若是，則JVM首先將在當前執行緒的棧幀中建立一個名為鎖記錄（Lock Record）的空間，用於存儲鎖對象目前的Mark Word的拷貝（官方把這份拷貝加了一個Displaced前綴，即Displaced Mark Word）；否則執行步驟（3）；
2. JVM利用CAS操作嘗試將對象的Mark Word更新為指向Lock Record的指正，如果成功表示競爭到鎖，則將鎖標誌位變成00（表示此對象處於輕量級鎖狀態），執行同步操作；如果失敗則執行步驟（3）；
3. 判斷當前對象的Mark Word是否指向當前執行緒的棧幀，如果是則表示當前執行緒已經持有當前對象的鎖，則直接執行同步程式碼塊；否則只能說明該鎖對象已經被其他執行緒搶佔了，這時輕量級鎖需要膨脹為重量級鎖，鎖標誌位變成10，後面等待的執行緒將會進入阻塞狀態；

釋放鎖 輕量級鎖的釋放也是通過CAS操作來進行的，主要步驟如下：

1. 取出在獲取輕量級鎖保存在Displaced Mark Word中的數據；
2. 用CAS操作將取出的數據替換當前對象的Mark Word中，如果成功，則說明釋放鎖成功，否則執行（3）；
3. 如果CAS操作替換失敗，說明有其他執行緒嘗試獲取該鎖，則需要在釋放鎖的同時需要喚醒被掛起的執行緒。

對於輕量級鎖，其性能提升的依據是「對於絕大部分的鎖，在整個生命周期內都是不會存在競爭的」，如果打破這個依據則除了互斥的開銷外，還有額外的CAS操作，因此在有多執行緒競爭的情況下，輕量級鎖比重量級鎖更慢；

下圖是輕量級鎖的獲取和釋放過程

偏向鎖

引入偏向鎖主要目的是：為了在無多執行緒競爭的情況下盡量減少不必要的輕量級鎖執行路徑。上面提到了輕量級鎖的加鎖解鎖操作是需要依賴多次CAS原子指令的。那麼偏向鎖是如何來減少不必要的CAS操作呢？我們可以查看Mark work的結構就明白了。只需要檢查是否為偏向鎖、鎖標識為以及ThreadID即可，處理流程如下： 獲取鎖

1. 檢測Mark Word是否為可偏向狀態，即是否為偏向鎖1，鎖標識位為01；
2. 若為可偏向狀態，則測試執行緒ID是否為當前執行緒ID，如果是，則執行步驟（5），否則執行步驟（3）；
3. 如果執行緒ID不為當前執行緒ID，則通過CAS操作競爭鎖，競爭成功，則將Mark Word的執行緒ID替換為當前執行緒ID，否則執行執行緒（4）；
4. 通過CAS競爭鎖失敗，證明當前存在多執行緒競爭情況，當到達全局安全點，獲得偏向鎖的執行緒被掛起，偏向鎖升級為輕量級鎖，然後被阻塞在安全點的執行緒繼續往下執行同步程式碼塊；
5. 執行同步程式碼塊

釋放鎖 偏向鎖的釋放採用了一種只有競爭才會釋放鎖的機制，執行緒是不會主動去釋放偏向鎖，需要等待其他執行緒來競爭。偏向鎖的撤銷需要等待全局安全點（這個時間點是上沒有正在執行的程式碼）。其步驟如下：

1. 暫停擁有偏向鎖的執行緒，判斷鎖對象石是否還處於被鎖定狀態；
2. 撤銷偏向蘇，恢復到無鎖狀態（01）或者輕量級鎖的狀態；

下圖是偏向鎖的獲取和釋放流程

重量級鎖

重量級鎖通過對象內部的監視器（monitor）實現，其中monitor的本質是依賴於底層作業系統的Mutex Lock實現，作業系統實現執行緒之間的切換需要從用戶態到內核態的切換，切換成本非常高。

參考資料

1. 周志明：《深入理解Java虛擬機》
2. 方騰飛：《Java並發編程的藝術》
3. Java中synchronized的實現原理與應用）