synchronized-1

 參考：

【Java併發編程實戰】—–synchronized

聊聊併發（二）Java SE1.6中的Synchronized

Java 併發進階常見面試題總結

【死磕Java併發】—–深刻分析synchronized 的實現原理

基本概念

一、基礎

臨界區是指一個訪問共用資源的程序片斷，而這些共用資源又沒法同時被多個線程訪問。

synchronized，咱們謂之鎖，主要用來給方法、代碼塊加鎖。

當某個方法或者代碼塊使用synchronized時，那麼在同一時刻至多僅有有一個線程在執行該段代碼。

當有多個線程訪問同一對象的加鎖方法/代碼塊時，同一時間只有一個線程在執行，

其他線程必需要等待當前線程執行完以後才能執行該代碼段。

可是，其他線程是能夠訪問該對象中的非加鎖代碼塊的。

不管synchronized關鍵字加在方法上仍是對象上，它取得的鎖都是對象。

在java中每個對象均可以做爲鎖，它主要體如今下面三個方面：

對於同步方法，鎖是當前實例對象

對於靜態同步方法，鎖是當前對象的Class對象。

static超脫於對象以外，它屬於類級別的。

因此，對象鎖就是該靜態放發所在的類的Class實例。

因爲在JVM中，全部被加載的類都有惟一的類對象，在該實例當中就是惟一的對象。

無論咱們建立了該類的多少實例，可是它的類實例仍然是一個！因此對象鎖是惟一且共享的。線程同步！

若是一個類中定義了一個synchronized的static函數A，也定義了一個synchronized的instance函數B，

那麼這個類的同一對象Obj,在多線程中分別訪問A和B兩個方法時，不會構成同步，

由於它們的鎖都不同。A方法的鎖是Obj這個對象，而B的鎖是Obj所屬的那個Class。

對於同步方法塊，鎖是Synchonized括號裏配置的對象。

二、對於 synchronized 關鍵字的瞭解

synchronized關鍵字解決的是多個線程之間訪問資源的同步性

synchronized關鍵字能夠保證被它修飾的方法或者代碼塊在任意時刻只能有一個線程執行。

另外，在 Java 早期版本中，synchronized屬於重量級鎖，效率低下，

由於監視器鎖（monitor）是依賴於底層的操做系統的 Mutex Lock 來實現的，

Java 的線程是映射到操做系統的原生線程之上的。

若是要掛起或者喚醒一個線程，都須要操做系統幫忙完成，

而操做系統實現線程之間的切換時須要從用戶態轉換到內核態，

這個狀態之間的轉換須要相對比較長的時間，時間成本相對較高，

這也是爲何早期的 synchronized 效率低的緣由。

慶幸的是在 Java 6 以後 Java 官方對從 JVM 層面對synchronized 較大優化，

因此如今的 synchronized 鎖效率也優化得很不錯了。

JDK1.6對鎖的實現引入了大量的優化，

如自旋鎖、適應性自旋鎖、鎖消除、鎖粗化、偏向鎖、輕量級鎖等技術來減小鎖操做的開銷。

三、怎麼使用 synchronized 關鍵字

synchronized關鍵字最主要的三種使用方式：

修飾實例方法: 做用於當前對象實例加鎖，進入同步代碼前要得到當前對象實例的鎖

修飾靜態方法: :也就是給當前類加鎖，會做用於類的全部對象實例，

由於靜態成員不屬於任何一個實例對象，是類成員（ static 代表這是該類的一個靜態資源，無論new了多少個對象，只有一份）。

因此若是一個線程A調用一個實例對象的非靜態 synchronized 方法，

而線程B須要調用這個實例對象所屬類的靜態 synchronized 方法，是容許的，

不會發生互斥現象，由於訪問靜態 synchronized 方法佔用的鎖是當前類的鎖，

而訪問非靜態 synchronized 方法佔用的鎖是當前實例對象鎖。

修飾代碼塊: 指定加鎖對象，對給定對象加鎖，進入同步代碼庫前要得到給定對象的鎖。

總結：

synchronized 關鍵字加到 static 靜態方法和 synchronized(class)代碼塊上都是是給 Class 類上鎖。

synchronized 關鍵字加到實例方法上是給對象實例上鎖。

儘可能不要使用 synchronized(String a) 由於JVM中，字符串常量池具備緩存功能！

深刻分析synchronized的實現原理

剛開始學習Java的時候，一遇到多線程狀況就是synchronized，

相對於當時的咱們來講synchronized是這麼的神奇而又強大，

那個時候咱們賦予它一個名字「同步」，也成爲了咱們解決多線程狀況的百試不爽的良藥。

可是，隨着咱們學習的進行咱們知道synchronized是一個重量級鎖，

相對於Lock，它會顯得那麼笨重，以致於咱們認爲它不是那麼的高效而慢慢摒棄它。

誠然，隨着Javs SE 1.6對synchronized進行的各類優化後，synchronized並不會顯得那麼重了。

一、實現原理

synchronized能夠保證方法或者代碼塊在運行時，

同一時刻只有一個方法能夠進入到臨界區，同時它還能夠保證共享變量的內存可見性

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

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

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

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

當一個線程訪問同步代碼塊時，它首先是須要獲得鎖才能執行同步代碼，當退出或者拋出異常時必需要釋放鎖，

那麼它是如何來實現這個機制的呢？咱們先看一段簡單的代碼：

public class SynchronizedTest {
    public synchronized void test1(){

    }

    public void test2(){
        synchronized (this){

        }
    }
}

View Code

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

 

 

 從上面能夠看出，同步代碼塊是使用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位虛擬機）：

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(){
        Vector<String> vector = new Vector<String>();
        for(int i = 0 ; i < 10 ; i++){
            vector.add(i + "");
        }

        System.out.println(vector);
    }

View Code

在運行這段代碼時，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操做來進行的，

主要步驟以下：

取出在獲取輕量級鎖保存在Displaced Mark Word中的數據；

用CAS操做將取出的數據替換當前對象的Mark Word中，若是成功，則說明釋放鎖成功，不然執行（3）；

若是CAS操做替換失敗，說明有其餘線程嘗試獲取該鎖，則須要在釋放鎖的同時須要喚醒被掛起的線程。

對於輕量級鎖，其性能提高的依據是「對於絕大部分的鎖，在整個生命週期內都是不會存在競爭的」，

若是打破這個依據則除了互斥的開銷外，還有額外的CAS操做，所以在有多線程競爭的狀況下，輕量級鎖比重量級鎖更慢；

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

 

 

 

偏向鎖

引入偏向鎖主要目的是：

爲了在無多線程競爭的狀況下儘可能減小沒必要要的輕量級鎖執行路徑。

上面提到了輕量級鎖的加鎖解鎖操做是須要依賴屢次CAS原子指令的。

那麼偏向鎖是如何來減小沒必要要的CAS操做呢？咱們能夠查看Mark work的結構就明白了。

只須要檢查是否爲偏向鎖、鎖標識爲以及ThreadID便可，處理流程以下：

獲取鎖

檢測Mark Word是否爲可偏向狀態，便是否爲偏向鎖1，鎖標識位爲01；

若爲可偏向狀態，則測試線程ID是否爲當前線程ID，若是是，則執行步驟（5），不然執行步驟（3）；

若是線程ID不爲當前線程ID，則經過CAS操做競爭鎖，競爭成功，則將Mark Word的線程ID替換爲當前線程ID，不然執行線程（4）；

經過CAS競爭鎖失敗，證實當前存在多線程競爭狀況，當到達全局安全點，得到偏向鎖的線程被掛起，偏向鎖升級爲輕量級鎖，而後被阻      塞在安全點的線程繼續往下執行同步代碼塊；

執行同步代碼塊

釋放鎖 偏向鎖的釋放採用了一種只有競爭纔會釋放鎖的機制，線程是不會主動去釋放偏向鎖，須要等待其餘線程來競爭。

偏向鎖的撤銷須要等待全局安全點（這個時間點是上沒有正在執行的代碼）。

其步驟以下：

暫停擁有偏向鎖的線程，判斷鎖對象石是否還處於被鎖定狀態；

撤銷偏向蘇，恢復到無鎖狀態（01）或者輕量級鎖的狀態

 

 

 

重量級鎖

重量級鎖經過對象內部的監視器（monitor）實現，其中monitor的本質是依賴於底層操做系統的Mutex Lock實現，

操做系統實現線程之間的切換須要從用戶態到內核態的切換，切換成本很是高。