為什麼95%的Java程式設計師，都是用不好Synchronized？

Synchronized鎖優化

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

鎖優化

偏向鎖

偏向鎖是Java 6之後加入的新鎖，它是一種針對加鎖操作的優化手段，經過研究發現，在大多數情況下，鎖不僅不存在多執行緒競爭，而且總是由同一執行緒多次獲得，因此為了減少同一執行緒獲取鎖(會涉及到一些CAS操作,耗時)的代價而引入偏向鎖。

偏向鎖的核心思想是，如果一個執行緒獲得了鎖，那麼鎖就進入偏向模式，此時Mark Word 的結構也變為偏向鎖結構，當這個執行緒再次請求鎖時，無需再做任何同步操作，即獲取鎖的過程，這樣就省去了大量有關鎖申請的操作，從而也就提供程式的效能。

所以，對於沒有鎖競爭的場合，偏向鎖有很好的優化效果，畢竟極有可能連續多次是同一個執行緒申請相同的鎖。但是對於鎖競爭比較激烈的場合，偏向鎖就失效了，

因為這樣場合極有可能每次申請鎖的執行緒都是不相同的，因此這種場合下不應該使用偏向鎖，否則會得不償失，需要注意的是，偏向鎖失敗後，並不會立即膨脹為重量級鎖，而是先升級為輕量級鎖。下面我們接著瞭解輕量級鎖。

引入偏向鎖主要目的是：為了在無多執行緒競爭的情況下儘量減少不必要的輕量級鎖執行路徑。上面提到了輕量級鎖的加鎖解鎖操作是需要依賴多次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）或者輕量級鎖的狀態；

輕量級鎖

倘若偏向鎖失敗，虛擬機器並不會立即升級為重量級鎖，它還會嘗試使用一種稱為輕量級鎖的優化手段(1.6之後加入的)，此時Mark Word 的結構也變為輕量級鎖的結構。

輕量級鎖能夠提升程式效能的依據是“對絕大部分的鎖，在整個同步週期內都不存在競爭”，注意這是經驗資料。需要了解的是，輕量級鎖所適應的場景是執行緒交替執行同步塊的場合，如果存在同一時間訪問同一鎖的場合，就會導致輕量級鎖膨脹為重量級鎖。

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

獲取鎖

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操作，因此在有多執行緒競爭的情況下，輕量級鎖比重量級鎖更慢；

自旋鎖

輕量級鎖失敗後，虛擬機器為了避免執行緒真實地在作業系統層面掛起，還會進行一項稱為自旋鎖的優化手段。

這是基於在大多數情況下，執行緒持有鎖的時間都不會太長，如果直接掛起作業系統層面的執行緒可能會得不償失，畢竟作業系統實現執行緒之間的切換時需要從使用者態轉換到核心態，這個狀態之間的轉換需要相對比較長的時間，時間成本相對較高，因此自旋鎖會假設在不久將來，

當前的執行緒可以獲得鎖，因此虛擬機器會讓當前想要獲取鎖的執行緒做幾個空迴圈(這也是稱為自旋的原因)，一般不會太久，可能是50個迴圈或100迴圈，在經過若干次迴圈後，如果得到鎖，就順利進入臨界區。

如果還不能獲得鎖，那就會將執行緒在作業系統層面掛起，這就是自旋鎖的優化方式，這種方式確實也是可以提升效率的。最後沒辦法也就只能升級為重量級鎖了。

執行緒的阻塞和喚醒需要CPU從使用者態轉為核心態，頻繁的阻塞和喚醒對CPU來說是一件負擔很重的工作，勢必會給系統的併發效能帶來很大的壓力。

同時我們發現在許多應用上面，物件鎖的鎖狀態只會持續很短一段時間，為了這一段很短的時間頻繁地阻塞和喚醒執行緒是非常不值得的。所以引入自旋鎖。

何謂自旋鎖？ 所謂自旋鎖，就是讓該執行緒等待一段時間，不會被立即掛起，看持有鎖的執行緒是否會很快釋放鎖。怎麼等待呢？執行一段無意義的迴圈即可（自旋），和CAS類似。

自旋等待不能替代阻塞，先不說對處理器數量的要求（多核，貌似現在沒有單核的處理器了），雖然它可以避免執行緒切換帶來的開銷，但是它佔用了處理器的時間。

如果持有鎖的執行緒很快就釋放了鎖，那麼自旋的效率就非常好，反之，自旋的執行緒就會白白消耗掉處理的資源，它不會做任何有意義的工作，典型的佔著茅坑不拉屎，這樣反而會帶來效能上的浪費。

所以說，自旋等待的時間（自旋的次數）必須要有一個限度，如果自旋超過了定義的時間仍然沒有獲取到鎖，則應該被掛起。

自旋鎖在JDK 1.4.2中引入，預設關閉，但是可以使用-XX:+UseSpinning開開啟，在JDK1.6中預設開啟。同時自旋的預設次數為10次，可以通過引數-XX:PreBlockSpin來調整；

如果通過引數-XX:preBlockSpin來調整自旋鎖的自旋次數，會帶來諸多不便。假如我將引數調整為10，但是系統很多執行緒都是等你剛剛退出的時候就釋放了鎖（假如你多自旋一兩次就可以獲取鎖），你是不是很尷尬。

於是JDK1.6引入自適應的自旋鎖，讓虛擬機器會變得越來越聰明。

適應自旋鎖

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

它怎麼做呢？執行緒如果自旋成功了，那麼下次自旋的次數會更加多，因為虛擬機器認為既然上次成功了，那麼此次自旋也很有可能會再次成功，那麼它就會允許自旋等待持續的次數更多。

反之，如果對於某個鎖，很少有自旋能夠成功的，那麼在以後要或者這個鎖的時候自旋的次數會減少甚至省略掉自旋過程，以免浪費處理器資源。

有了自適應自旋鎖，隨著程式執行和效能監控資訊的不斷完善，虛擬機器對程式鎖的狀況預測會越來越準確，虛擬機器會變得越來越聰明。

鎖消除

消除鎖是虛擬機器另外一種鎖的優化，這種優化更徹底，Java虛擬機器在JIT編譯時(可以簡單理解為當某段程式碼即將第一次被執行時進行編譯，又稱即時編譯).

通過對執行上下文的掃描，去除不可能存在共享資源競爭的鎖，通過這種方式消除沒有必要的鎖，可以節省毫無意義的請求鎖時間，如下StringBuffer的append是一個同步方法，但是在add方法中的StringBuffer屬於一個區域性變數，並且不會被其他執行緒所使用

因此StringBuffer不可能存在共享資源競爭的情景，JVM會自動將其鎖消除。

為了保證資料的完整性，我們在進行操作時需要對這部分操作進行同步控制，但是在有些情況下，JVM檢測到不可能存在共享資料競爭，這是JVM會對這些同步鎖進行鎖消除。

鎖消除的依據是逃逸分析的資料支援。 如果不存在競爭，為什麼還需要加鎖呢？所以鎖消除可以節省毫無意義的請求鎖的時間。

變數是否逃逸，對於虛擬機器來說需要使用資料流分析來確定，但是對於我們程式設計師來說這還不清楚麼？我們會在明明知道不存在資料競爭的程式碼塊前加上同步嗎？

但是有時候程式並不是我們所想的那樣？我們雖然沒有顯示使用鎖，但是我們在使用一些JDK的內建API時，如StringBuffer、Vector、HashTable等，這個時候會存在隱形的加鎖操作。

比如StringBuffer的append()方法，Vector的add()方法：

COPYpublic 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內部的加鎖操作消除。

逃逸分析

如果證明一個物件不會逃逸方法外或者執行緒外，則可針對此變數進行優化：

同步消除synchronization Elimination，如果一個物件不會逃逸出執行緒，則對此變數的同步措施可消除。

重量級鎖

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

為什麼重量級鎖的開銷比較大呢

原因是當系統檢查到是重量級鎖之後，會把等待想要獲取鎖的執行緒阻塞，被阻塞的執行緒不會消耗CPU，但是阻塞或者喚醒一個執行緒，都需要通過作業系統來實現，也就是相當於從使用者態轉化到核心態，而轉化狀態是需要消耗時間的

三種鎖的區別

鎖	優點	缺點	使用場景
偏向鎖	加鎖和解鎖不需要CAS，沒有額外的效能消耗，和執行非同步方法相比，僅存在納秒級的差距	如果執行緒間存在鎖競爭，會帶來額外的鎖撤銷的消耗	只有一個執行緒訪問同步塊或者同步方法的場景
輕量級鎖	競爭的執行緒不會阻塞提高響應速度	若執行緒長時間搶不到鎖，自旋會消耗CPU效能	執行緒交替執行同步塊或者同步方法的場景
重量級鎖	執行緒競爭不使用自旋，不消耗CPU	執行緒阻塞，響應時間緩慢,在多執行緒下,頻繁的獲取釋放鎖，會帶來巨大的效能消耗	追求吞吐量，同步塊或者同步方法執行時間較長的場景

鎖升級

偏向鎖升級輕量級鎖：當一個物件持有偏向鎖，一旦第二個執行緒訪問這個物件，如果產生競爭，偏向鎖升級為輕量級鎖。

輕量級鎖升級重量級鎖：一般兩個執行緒對於同一個鎖的操作都會錯開，或者說稍微等待一下（自旋），另一個執行緒就會釋放鎖。但是當自旋超過一定的次數，或者一個執行緒在持有鎖，一個在自旋，又有第三個來訪時，輕量級鎖膨脹為重量級鎖，重量級鎖使除了擁有鎖的執行緒以外的執行緒都阻塞，防止CPU空轉。

鎖粗化

我們知道在使用同步鎖的時候，需要讓同步塊的作用範圍儘可能小—僅在共享資料的實際作用域中才進行同步，這樣做的目的是為了使需要同步的運算元量儘可能縮小，如果存在鎖競爭，那麼等待鎖的執行緒也能儘快拿到鎖。 ​ 在大多數的情況下，上述觀點是正確的，LZ也一直堅持著這個觀點。

但是如果一系列的連續加鎖解鎖操作，可能會導致不必要的效能損耗，所以引入鎖粗話的概念。 鎖粗話概念比較好理解，就是將多個連續的加鎖、解鎖操作連線在一起，擴充套件成一個範圍更大的鎖。

如下面的例子，一個方法由兩個加鎖,因為num = x + y;耗時較短，對比兩次鎖短的多，就會鎖粗化。

COPYprivate int x, y;

   /**
    * 因為一個方法需要兩個加鎖解鎖耗費資源
    * 對於  num = x + y; 耗費時間很短 就會將
    * 程式碼包裹進去組成一個鎖
    * @return
    */
   public int lockCoarsening() {
       int num = 0;
       //物件鎖
       synchronized (this) {
           x++;
           //todo 處理部分業務
       }
       num = x + y;
       //物件鎖
       synchronized (this) {
           y++;
           //todo 處理部分業務
       }
       return num;
   }

粗化後

COPYprivate int x, y;

  /**
   * 使用一個鎖
   *
   * @return
   */
  public int lockCoarsening() {
      int num = 0;
      //只進行一次加鎖解鎖
      synchronized (this) {
          x++;
          //todo 處理部分業務
          num = x + y;
          y++;
          //todo 處理部分業務
      }
      return num;
  }

wait和notify的原理

呼叫wait方法，首先會獲取監視器鎖，獲得成功以後，會讓當前執行緒進入等待狀態進入等待佇列並且釋放鎖。

當其他執行緒呼叫notify後，會選擇從等待佇列中喚醒任意一個執行緒，而執行完notify方法以後，並不會立馬喚醒執行緒，原因是當前的執行緒仍然持有這把鎖，處於等待狀態的執行緒無法獲得鎖。必須要等到當前的執行緒執行完按monitorexit指令以後，也就是鎖被釋放以後，處於等待佇列中的執行緒就可以開始競爭鎖了。

wait和notify為什麼需要在synchronized裡面？

wait方法的語義有兩個，一個是釋放當前的物件鎖、另一個是使得當前執行緒進入阻塞佇列，而這些操作都和監視器是相關的，所以wait必須要獲得一個監視器鎖。

而對於notify來說也是一樣，它是喚醒一個執行緒，既然要去喚醒，首先得知道它在哪裡，所以就必須要找到這個物件獲取到這個物件的鎖，然後到這個物件的等待佇列中去喚醒一個執行緒。

本文由傳智教育博學谷狂野架構師教研團隊釋出。

如果本文對您有幫助，歡迎關注和點贊；如果您有任何建議也可留言評論或私信，您的支援是我堅持創作的動力。

轉載請註明出處！