Java併發指南4：Java中的鎖 Lock和synchronized

Java中的鎖機制及Lock類

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

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

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

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

根據程序次序規則，1 happens before 2, 2 happens before 3; 4 happens before 5, 5 happens before 6。假設線程A執行writer()方法，隨後線程B執行reader()方法。根據happens before規則，這個過程包含的happens before 關係能夠分爲兩類：

1. 根據監視器鎖規則，3 happens before 4。
2. 根據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底層實現）依靠的是方法修飾符上的ACC_SYNCHRONIZED實現。 
同步代碼塊：monitorenter指令插入到同步代碼塊的開始位置，monitorexit指令插入到同步代碼塊的結束位置，JVM須要保證每個monitorenter都有一個monitorexit與之相對應。任何對象都有一個monitor與之相關聯，當且一個monitor被持有以後，他將處於鎖定狀態。線程執行到monitorenter指令時，將會嘗試獲取對象所對應的monitor全部權，即嘗試獲取對象的鎖； 
同步方法：synchronized方法則會被翻譯成普通的方法調用和返回指令如:invokevirtual、areturn指令，在VM字節碼層面並無任何特別的指令來實現被synchronized修飾的方法，而是在Class文件的方法表中將該方法的access_flags字段中的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引入了更加聰明的自旋鎖，即自適應自旋鎖。所謂自適應就意味着自旋的次數再也不是固定的，它是由前一次在同一個鎖上的自旋時間及鎖的擁有者的狀態來決定。它怎麼作呢？線程若是自旋成功了，那麼下次自旋的次數會更加多，由於虛擬機認爲既然上次成功了，那麼這次自旋也頗有可能會再次成功，那麼它就會容許自旋等待持續的次數更多。反之，若是對於某個鎖，不多有自旋可以成功的，那麼在之後要或者這個鎖的時候自旋的次數會減小甚至省略掉自旋過程，以避免浪費處理器資源。 
有了自適應自旋鎖，隨着程序運行和性能監控信息的不斷完善，虛擬機對程序鎖的情況預測會愈來愈準確，虛擬機會變得愈來愈聰明。

1、自旋鎖的概念
首先是一種鎖，與互斥鎖類似，基本做用是用於線程（進程）之間的同步。與普通鎖不一樣的是，一個線程A在得到普通鎖後，若是再有線程B試圖獲取鎖，那麼這個線程B將會掛起（阻塞）；試想下，若是兩個線程資源競爭不是特別激烈，而處理器阻塞一個線程引發的線程上下文的切換的代價高於等待資源的代價的時候（鎖的已保持者保持鎖時間比較短），那麼線程B能夠不放棄CPU時間片，而是在「原地」忙等，直到鎖的持有者釋放了該鎖，這就是自旋鎖的原理，可見自旋鎖是一種非阻塞鎖。
2、自旋鎖可能引發的問題：
1.過多佔據CPU時間：若是鎖的當前持有者長時間不釋放該鎖，那麼等待者將長時間的佔據cpu時間片，致使CPU資源的浪費，所以能夠設定一個時間，當鎖持有者超過這個時間不釋放鎖時，等待者會放棄CPU時間片阻塞；
2.死鎖問題：試想一下，有一個線程連續兩次試圖得到自旋鎖（好比在遞歸程序中），第一次這個線程得到了該鎖，當第二次試圖加鎖的時候，檢測到鎖已被佔用（實際上是被本身佔用），那麼這時，線程會一直等待本身釋放該鎖，而不能繼續執行，這樣就引發了死鎖。所以遞歸程序使用自旋鎖應該遵循如下原則：遞歸程序決不能在持有自旋鎖時調用它本身，也決不能在遞歸調用時試圖得到相同的自旋鎖。

鎖消除

爲了保證數據的完整性，咱們在進行操做時須要對這部分操做進行同步控制，可是在有些狀況下，JVM檢測到不可能存在共享數據競爭，這是JVM會對這些同步鎖進行鎖消除。鎖消除的依據是逃逸分析的數據支持。 
若是不存在競爭，爲何還須要加鎖呢？因此鎖消除能夠節省毫無心義的請求鎖的時間。變量是否逃逸，對於虛擬機來講須要使用數據流分析來肯定，可是對於咱們程序員來講這還不清楚麼？咱們會在明明知道不存在數據競爭的代碼塊前加上同步嗎？可是有時候程序並非咱們所想的那樣？咱們雖然沒有顯示使用鎖，可是咱們在使用一些JDK的內置API時，如StringBuffer、Vector、HashTable等，這個時候會存在隱形的加鎖操做。好比StringBuffer的append()方法，Vector的add()方法：

public void vectorTest(){        Vector<String> vector = new Vector<String>();        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的實現原理與應用

更多內容請關注微信公衆號【Java技術江湖】

一位阿里 Java 工程師的技術小站。做者黃小斜，專一 Java 相關技術：SSM、SpringBoot、MySQL、分佈式、中間件、集羣、Linux、網絡、多線程，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！（關注公衆號後回覆」Java「便可領取 Java基礎、進階、項目和架構師等免費學習資料，更有數據庫、分佈式、微服務等熱門技術學習視頻，內容豐富，兼顧原理和實踐，另外也將贈送做者原創的Java學習指南、Java程序員面試指南等乾貨資源）