[鎖] Synchronized總結

一  synchronized加鎖原理

　　synchronized能夠保證方法或者代碼塊在運行時，同一時刻只有一個線程能夠進入到臨界區，同時它還能夠保證共享變量的內存可見性。

　　Java中每個對象均可以做爲鎖，這是synchronized實現同步的基礎：

　　　　（1）普通同步方法，鎖是當前實例對象

　　　　（2）靜態同步方法，鎖是當前類的class對象

　　　　（3）同步方法塊，鎖是括號裏面的對象

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

public class SynchronizedTest {
    public synchronized void test1(){

    }

    public void test2(){
        synchronized (this){

        }
    }
}

 利用javap工具查看生成的class文件信息來分析Synchronize的實現以下圖：

　　 

　　從上圖能夠看出，同步代碼塊是使用monitorenter和monitorexit指令實現的，同步方法依靠的是方法修飾符上的ACC_SYNCHRONIZED實現。

　　同步代碼塊：monitorenter指令插入到同步代碼塊的開始位置，monitorexit指令插入到同步代碼塊的結束位置，JVM須要保證每個monitorenter都有一個monitorexit與之相對應。任何對象都有一個monitor與之相關聯，當且一個monitor被持有以後，他將處於鎖定狀態。線程執行到monitorenter指令時，將會嘗試獲取對象所對應的monitor全部權，即嘗試獲取對象的鎖；

　　同步方法：synchronized方法則會被翻譯成普通的方法調用和返回指令如：invokevirtual、areturn指令，在JVM字節碼層面並無任何特別的指令來實現被synchronized修飾的方法，而是在Class文件的方法表中將該方法的access_flags字段中的synchronized標誌位置1，表示該方法是同步方法並使用調用該方法的對象或該方法所屬的Class在JVM的內部對象表示Klass作爲鎖對象。

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表示要喚醒一個繼任線程來競爭鎖。

 三  鎖優化

　　JDK1.6對鎖的實現引入了大量的優化，如自旋鎖、適應性自旋鎖、鎖消除、鎖粗化、偏向鎖、輕量級鎖等技術來減小鎖操做的開銷。

　　鎖主要存在四中狀態，依次是：無鎖狀態、偏向鎖狀態、輕量級鎖狀態、重量級鎖狀態，他們會隨着競爭的激烈而逐漸升級。注意鎖能夠升級不可降級，這種策略是爲了提升得到鎖和釋放鎖的效率。

1  自旋鎖

　　因爲線程的阻塞和喚醒須要CPU從用戶態轉爲內核態，所以頻繁的阻塞和喚醒線程對CPU來講是一件負擔很重的工做，勢必會給系統的併發性能帶來很大的壓力。同時咱們發如今許多應用上面，對象鎖的鎖狀態只會持續很短一段時間，爲了這一段很短的時間頻繁地阻塞和喚醒線程是很是不值得的。因此引入自旋鎖。

　　所謂自旋鎖，就是讓該線程等待一段時間，不會被當即掛起，看持有鎖的線程是否會很快釋放鎖。怎麼等待呢？執行一段無心義的循環便可（自旋，for(;;)）。

　　自旋等待不能替代阻塞，雖然它能夠避免線程切換帶來的開銷，可是它佔用了處理器的時間。

　　若是持有鎖的線程很快就釋放了鎖，那麼自旋的效率就很是好，反之，自旋的線程就會白白消耗掉處理器的資源，它不會作任何有意義的工做，這樣反而會帶來性能上的浪費。因此說，自旋等待的時間（自旋的次數）必需要有一個限度，若是自旋超過了定義的時間仍然沒有獲取到鎖，則應該被掛起。

　　自旋鎖在JDK 1.4.2中引入，默認關閉，可是可使用-XX:+UseSpinning開開啓，在JDK1.6中默認開啓。同時自旋的默認次數爲10次，能夠經過參數-XX:PreBlockSpin來調整；

　　若是經過參數-XX:preBlockSpin來調整自旋鎖的自旋次數，會帶來諸多不便。假如我將參數調整爲10，可是系統不少線程都是等你剛剛退出自旋的時候就釋放了鎖（例如你多自旋一兩次就能夠獲取鎖）。因而JDK1.6引入自適應的自旋鎖，讓虛擬機會變得愈來愈聰明。

2  自適應自旋鎖

　　JDK 1.6引入了自適應自旋鎖。所謂自適應就意味着自旋的次數再也不是固定的，它是由前一次在同一個鎖上的自旋時間及鎖的擁有者的狀態來決定。

　　線程若是自旋加鎖成功了，那麼增長下一次自旋的次數，由於虛擬機認爲既然上次成功了，那麼這次自旋也頗有可能會再次成功，那麼它就會容許自旋等待持續的次數更多。反之，若是對於某個鎖，不多有自旋可以成功的，那麼在之後要或者這個鎖的時候自旋的次數會減小甚至省略掉自旋過程，以避免浪費處理器資源。

　　有了自適應自旋鎖，隨着程序運行和性能監控信息的不斷完善，虛擬機對程序鎖的情況預測會愈來愈準確，虛擬機會變得愈來愈聰明。

3  鎖消除

　　參考：逃逸分析　　https://www.cnblogs.com/aiqiqi/p/10650394.html

　　爲了保證數據的完整性，咱們在進行操做時須要對這部分操做進行同步控制，可是在有些狀況下，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內部的加鎖操做消除。

4  鎖粗化

　　在使用同步鎖的時候，須要讓同步塊的做用範圍儘量小，僅在共享數據的實際做用域中才進行同步，這樣作的目的是爲了使須要同步的操做數量儘量縮小，若是存在鎖競爭，那麼等待鎖的線程也能儘快拿到鎖。

　　可是若是一系列的連續加鎖解鎖操做，可能會致使沒必要要的性能損耗，因此引入鎖粗化的概念。

　　鎖粗化概念比較好理解，就是將多個連續的加鎖、解鎖操做鏈接在一塊兒，擴展成一個範圍更大的鎖。如上面實例：vector每次add的時候都須要加鎖操做，JVM檢測到對同一個對象（vector）連續加鎖、解鎖操做，會合並一個更大範圍的加鎖、解鎖操做，即加鎖解鎖操做會移到for循環以外。

5  輕量級鎖

　　引入輕量級鎖的主要目的是在多沒有多線程競爭的前提下，減小傳統的重量級鎖使用操做系統互斥量產生的性能消耗。當關閉偏向鎖功能或者多個線程競爭偏向鎖致使偏向鎖升級爲輕量級鎖，則會嘗試獲取輕量級鎖，其步驟以下：

　　獲取鎖

　　（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操做，所以在有多線程競爭的狀況下，輕量級鎖比重量級鎖更慢；

（6）偏向鎖

　　引入偏向鎖主要目的是：爲了在無多線程競爭的狀況下儘可能減小沒必要要的輕量級鎖執行路徑。上面提到了輕量級鎖的加鎖解鎖操做是須要依賴屢次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）或者輕量級鎖的狀態；

（7）重量級鎖

　　重量級鎖經過對象內部的監視器（monitor）實現，其中monitor的本質是依賴於底層操做系統的Mutex Lock實現，操做系統實現線程之間的切換須要從用戶態到內核態的切換，切換成本很是高。

 四  synchronized加鎖分析

　　synchronized可以鎖當前對象，也可以鎖類。 
　　synchronized鎖住當前對象的寫法：

　　public synchronized void a(){ 
　　　　do somesing...
　　}

　　public void ab(){ 
　　　　synchronized (this){ 
　　　　　　do somesing...
　　　　} 
　　}

synchronized鎖住當前類對象的寫法： 

public synchronized static void a(){ 
　　do somesing...
} 
public static void a(){ 
　　synchronized (類名){ 
　　　　do somesing...
　　} 
} 
public void ab(){ 
　　synchronized (類名){ 
　　　　do somesing...
　　} 
} 

　　當synchronized做用在對象時候，同一個對象中的線程是相互排斥的，僅僅有一個線程運行完畢後。另一個線程才幹得到對象鎖獲得運行。若是不是同一個對象，則不會產生相互排斥 。

　　當synchronized做用在類時，對於同一個jvm中不一樣對象的多個線程調用同一個synchronized修飾的方法都是相互排斥的。因爲一個jvm僅僅會爲一個class文件產生同一個class對象。

　　類鎖實際上用對象鎖來實現。當虛擬機裝載一個class文件的時候，它就會建立一個java.lang.Class類的實例對象。當鎖住一個類（synchronized (類名)）的時候，實際上鎖住的是那個類的Class對象。

　　synchronized支持可重入性，一個線程能夠屢次對同一個對象上鎖。對於每個對象，java虛擬機維護一個加鎖計數器，線程每得到一次該對象，計數器就加1，每釋放一次，計數器就減 1，當計數器值爲0時，鎖就被徹底釋放了。

五  Synchronized和Lock的區別

　　1. 首先synchronized是java內置關鍵字，在jvm層面，Lock是個java類；

　　2. synchronized沒法判斷是否獲取鎖的狀態，Lock能夠判斷是否獲取到鎖；

　　3. synchronized會自動釋放鎖(a 線程執行完同步代碼會釋放鎖 ；b 線程執行過程當中發生異常會釋放鎖)，Lock需在finally中手工釋放鎖（unlock()方法釋放鎖），不然容易形成線程死鎖；

　　4. 用synchronized關鍵字的兩個線程1和線程2，若是當前線程1得到鎖，線程2等待。若是線程1阻塞，線程2則會一直等待下去，而Lock鎖就不必定會等待下去，若是嘗試獲取不到鎖，線程能夠不用一直等待就結束了；

　　5. synchronized的鎖可重入、不可中斷、非公平，而Lock鎖可重入、可中斷、可公平（二者皆可）

　　6. Lock鎖適合大量同步的代碼的同步問題，synchronized鎖適合代碼少許的同步問題。

　　7. Lock能提升多個線程讀操做的效率。

　　7. synchronized能鎖住類、方法和代碼塊，而Lock是塊範圍內的