JDK成長記15：從0分析你不知道的synchronized底層原理（上）

前幾節你應該已經了解和掌握了Thread、ThreadLocal、Volatile這幾個并發基礎知識的底層原理，這一節，你可以跟我一起深入了解下synchronized關鍵字的底層原理和其涉及的基礎知識，看完這篇成長記，你可以獲取到如下幾點：

synchronized預備知識：

• 理解什么是CAS？
• synchronized會形成幾種鎖的型別
• HotspotJVM虛擬機Java物件記憶體中的布局結構是什么，markword是鎖的關鍵欄位？
• 作業系統中用戶態和內核態的資源操作和行程是什么意思？

synchronized核心流程及原理：

• 從3個層面初步分析sychronized的核心流程和原理

好了，讓我們一起開始吧！

HelloSychronized

HelloSychronized

我們來寫一個多執行緒i++的程式，體驗一下，多執行緒如果是并發的修改一個資料，會有什么樣的執行緒并發安全問題，

剛才說過了，volatile，解決的對一個共享資料，有人寫，有人讀，多個執行緒并發讀和寫的可見性的問題，而多個執行緒對一個共享資料并發的寫，可能會導致資料出錯，產生原子性的問題，

volatile為什么不能保證原子性？ 從JMM記憶體模型就可以看出來，多個執行緒同時修改一個變數，都是在自己本地記憶體中修改，volatile只是保證一個執行緒修改，另一個執行緒讀的時候，發起修改的執行緒是強制重繪資料主存，過期其他執行緒的作業記憶體的快取，沒法做到多個執行緒在本地記憶體同時寫的時候，限制只能有一個執行緒修改，因為執行緒自己修改自己記憶體的資料沒有發生競爭關系，而且之后會給各自寫入主記憶體，當然就保證不了只能有一個執行緒修改主記憶體的資料，做不到原子性了，

為了解決這個問題，可以使用syncrhonized給修改這個操作加一把鎖，一旦說某個執行緒加了一把鎖之后，就會保證，其他的執行緒沒法去讀取和修改這個變數的值了，同一時間，只有一個執行緒可以讀這個資料以及修改這個資料，別的執行緒都會卡在嘗試獲取鎖那兒，這樣也就不會出現并發同時修改，資料出錯，原子性問題了，

synchronized鎖一般有兩類，一種是對某個實體物件來加鎖，另外一種是對這個類進行加鎖，相信大家很熟悉了，這里用一個Hello synchronized的小例子，舉一個簡單物件加鎖的例子，

代碼如下：

  public class HelloSynchronized {
    public static void main(String[] args) {
      Object o = new Object();
      synchronized (o){
      }
    }
  }

對類加鎖和對實體物件的更多例子這里就不舉例了，我們更多的是研究synchronized它的底層原理，基本的使用相信你一定可以自己學習到，

在分析sychronized原理期間，需要不斷的補充一些基礎知識，

學習sychronized先決條件(Prerequisites)

學習sychronized先決條件(Prerequisites)

• sychronized鎖的概念

在JDK 早期 sychronized 使用的時候，直接創建的重量級鎖，性能很不好，

在之后JDK新的版本中，sychronized優化了鎖，分為了4種，無鎖態、偏向鎖、自旋鎖（輕量鎖）、重量鎖，會根據情況自動升級鎖，

這四種鎖分別表示什么意思呢？

無鎖態表示第一次對剛創建的物件或者類加鎖時的狀態，我發現只有一個執行緒在操作代碼塊的資源，壓根不需要加鎖，此時會處于無鎖態，

偏向鎖，類似于貼標簽，表示這個資源暫時屬于某個執行緒，偏向它所有了，打個比方，就好比一個座位只能做一個人，你坐下后，在座位上貼上了你自己的標簽，別人發現已經有標簽了，肯定就不會在坐了，

輕量鎖（自旋鎖）：輕量鎖，底層是CAS自旋的操作，所以也叫自旋鎖，這里簡單普及下自旋CAS的操作流程，之后將Aotmic類的時候會仔細講下，CAS自旋流程如下：

最后我們來聊下什么是重量級鎖？這又要牽扯另一個知識了，在Linux作業系統層面，由于需要限制不同的程式之間的訪問能力, 防止他們獲取別的程式的記憶體資料, 或者獲取外圍設備的資料, 并發送到網路, CPU劃分出兩個權限等級用戶態和內核態，用于表示行程運行時所處狀態，

你可以簡單理解，一個程式啟動后會有對應的行程，它們操作的資源分為兩種，屬于用戶態的資源或者內核態的資源，

用戶態是不能直接操作內核態中資源的，只能通知內核態來操作，這個在硬體級別也有對應的指令級別（比如Intel ring0-ring3級別的指令，ring0級別一般對應的就是用戶態行程可以操作的指令，ring3對應的是內核態行程可以發起的指令），

如下圖所示：

這個和synchronized有什么關系呢？因為synchronized加重量級鎖的操作，是對硬體資源的鎖指令操作，所以肯定是需要處于內核態的行程才可以操作，JVM的行程只是處于用戶態的行程，所以需要向作業系統申請，這個程序肯定會很消耗資源的，

比如，synchronized的本質是JVM用戶空間的一個行程（處于用戶態）向作業系統(內核態)發起一個lock的鎖指令操作 ，

C++代碼如下：

  //Adding a lock prefix to an instruction on MP machine
  \#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; local; 1 : "

如下圖右邊所示：

• sychronized鎖狀態的記錄

了解了sychronized的鎖的幾種型別后，怎么標識是什么樣的synchronized鎖呢？這個就要聊到Java的物件在JVM的記憶體中的結構了，不同虛擬機結構略有差別，這里講一下HotSpot虛擬機中的物件結構：

synchronized鎖狀態的資訊就記錄在markword中，markword在64位的作業系統上，8位元組，64位大小的空間的區域，

不同的鎖的標記在如下圖所示：

這個表你不用背下來，你只要知道，synchronized的輕量鎖和重量鎖通過2位即可以區分出來，偏向鎖和無鎖需要3位，

有了上面的基礎知識后，就可以開始研究synchronized的底層原理了，

位元組碼層面的synchronized

synchronized

sychronized在Java代碼層面就如上面Hello Synconized那個最簡單的例子所示，我們來看下它的位元組碼層面是什么樣子的？

上面main方法的位元組碼如下：

0 new #2 <java/lang/Object>
 3 dup
 4 invokespecial #1 <java/lang/Object.<init>>
 7 astore_1
 8 aload_1
 9 dup
 10 astore_2
 11 monitorenter
 12 aload_2
 13 monitorexit
 14 goto 22 (+8)
 17 astore_3
 18 aload_2
 19 monitorexit
 20 aload_3
 21 athrow
 22 return

new、dup、invokespecial、 astore_1這些指令是學習volatile的時候你應該很熟悉了，我這里需要關注的是另外 2個核心的JVM指令：monitorenter、monitorexit，

這個表示sychronized加鎖的同步代碼塊的進入和退出，為什么有兩個monitorexit呢？一個是正常退出，一個拋出例外也會退出釋放鎖，

JVM層面的synchronized

JVM層面的synchronized

那么，當 JVM的HotSpot實作中，當遇到這兩個JVM指令，又是如何執行的呢？讓我們來看一下，

在JVM HotSpot的C++代碼實際執行程序中，執行了一個InterpreterRuntime:: monitorenter方法，代碼如下：

  IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))

  \#ifdef ASSERT
   thread->last_frame().interpreter_frame_verify_monitor(elem);
  \#endif

   if (PrintBiasedLockingStatistics) {
    Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
   }

   Handle h_obj(thread, elem->obj());

  assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
       "must be NULL or an object");
   if (UseBiasedLocking) {
    // Retry fast entry if bias is revoked to avoid unnecessary inflation
    ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
   } else {
    ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
   }

   assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),

       "must be NULL or an object");

  \#ifdef ASSERT

   thread->last_frame().interpreter_frame_verify_monitor(elem);

  \#endif

  IRT_END

你可以看下上面的方法的脈絡（不懂C++也沒有關系，懂if-else就行），它的核心有兩個if，

第一個if根據變數名字PrintBiasedLockingStatistics可以判斷出應該是列印偏向鎖的統計資訊，明顯不是最重要的，

第二個if同理，UseBiasedLocking表示了是否使用了偏向鎖，如果是呼叫了ObjectSynchronizer::fast_enter否則

ObjectSynchronizer::slow_enter，

很明顯，第二個if中是synchronized加鎖的核心代碼，我們還需要繼續看下它們的脈絡，

代碼如下：synchronizer.cpp

void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS) {

    if (UseBiasedLocking) {
      if (!SafepointSynchronize::is_at_safepoint()) {
       BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);

       if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
        return;
       }

      } else {
       assert(!attempt_rebias, "can not rebias toward VM thread");
       BiasedLocking::revoke_at_safepoint(obj);
      }
      assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
    }
  
    slow_enter (obj, lock, THREAD) ;

    }

可以看到fast_enter方法，核心脈絡除了取消偏向和重新偏向的邏輯（從變數明和注釋可以看出來，這里暫時不重要，先忽略），最后核心脈絡還是呼叫了slow_enter方法，讓我們來看下：

void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {

   markOop mark = obj->mark();
   assert(!mark->has_bias_pattern(), "should not see bias pattern here"); 

   if (mark->is_neutral()) {
    // Anticipate successful CAS -- the ST of the displaced mark must
    // be visible <= the ST performed by the CAS.
    lock->set_displaced_header(mark);
    if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
     TEVENT (slow_enter: release stacklock) ;
     return ;
    }
    // Fall through to inflate() ...
   } else

   if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
    assert(lock != mark->locker(), "must not re-lock the same lock");
    assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
    lock->set_displaced_header(NULL);
    return;
   }


  \#if 0
   // The following optimization isn't particularly useful.
  if (mark->has_monitor() && mark->monitor()->is_entered(THREAD)) {
    lock->set_displaced_header (NULL) ;
    return ;
   }
  \#endif   

   // The object header will never be displaced to this lock,
   // so it does not matter what the value is, except that it
   // must be non-zero to avoid looking like a re-entrant lock,
   // and must not look locked either.
   lock->set_displaced_header(markOopDesc::unused_mark());
   ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD);

  }

上面這一段是sychronized加鎖，核心中的核心，可以發現很多有意思的地方：

1） 從注釋可以看出，鎖會有膨脹程序，物件頭會記錄鎖的相關資訊，

2） Atomic::cmpxchg_ptr體現了ompare and exchange (CAS)操作，是輕量級鎖，

3） mark->has_locker() && THREAD->is_lock_owned((address)mark->locker()體現了synchronized是可重入鎖

4） 最后的ObjectSynchronizer::inflate意思為膨脹為重量級鎖，

C++的代碼有很多細節和知識，你開始學習的時候不要想著全部搞清楚，一定要有之前學到的思想，先脈絡后細節，搞清楚脈絡再說研究細節的部分，

所以，通過初步看過synchronized的HotSpot C++代碼實作，重點的脈絡就是鎖升級的程序和原理，接下來重點分析一下這個程序，

synchronized鎖升級的程序

synchronized鎖升級的程序

前面通過從位元組碼層面到JVM層面初步了解了synchronized的實作，結合之前說的sychronized的鎖的幾種型別，最終可以分析出來synchronized鎖會有一個升級的程序，程序如下圖所示：

這個圖非常重要，大家一定要牢記住，下一節會花費整整一節來講在這個圖，

本文由博客群發一文多發等運營工具平臺 OpenWrite 發布

標籤：Java

上一篇：Exception和Error的區別

下一篇：Java專案中常用的的五大設計原則