前幾節你應該已經瞭解和掌握了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 釋出