為什么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，但是阻塞或者喚醒一個執行緒，都需要通過作業系統來實作，也就是相當于從用戶態轉化到內核態，而轉化狀態是需要消耗時間的

三種鎖的區別

鎖升級

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

輕量級鎖升級重量級鎖：一般兩個執行緒對于同一個鎖的操作都會錯開，或者說稍微等待一下（自旋），另一個執行緒就會釋放鎖，但是當自旋超過一定的次數，或者一個執行緒在持有鎖，一個在自旋，又有第三個來訪時，輕量級鎖膨脹為重量級鎖，重量級鎖使除了擁有鎖的執行緒以外的執行緒都阻塞，防止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來說也是一樣，它是喚醒一個執行緒，既然要去喚醒，首先得知道它在哪里，所以就必須要找到這個物件獲取到這個物件的鎖，然后到這個物件的等待佇列中去喚醒一個執行緒，

本文由傳智教育博學谷狂野架構師教研團隊發布，

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

轉載請注明出處！

標籤：其他

上一篇：Python寫一個自動發送直播彈幕的工具，非常好用！

下一篇：Python教程：類的繼承，什么是繼承