首先要解釋清楚這幾種鎖的特徵和區別，以及執行時候的變化，需要了解Java物件頭的一些知識，在Java物件頭的Mark Word內就記錄著這些不同鎖的狀態位。另外偏向鎖---輕量級鎖---重量級鎖本文都需要依託synchronize進行理解和分析。另外也要參照網路上很多的資料。

1.物件頭：

關於物件頭的具體記錄，可以參考這邊：物件頭

2.同步的原理：

1.資料儲存的變化---(主要針對Mark Word)

1.1基礎狀態 

在執行期間，物件頭內Mark Word記憶體儲的資料會隨著鎖標誌位的變化而變化，具體分為以下4種（基於32位虛擬機器）：

1.2 c++中的儲存結構分析和探究

上圖中的Mark Word是一個表格式的展示樣式，也是我從虛擬機器書中和網路上找來的，但是我還是去搜羅了一下c++中的結構資料，便於下面對於流程的分析。

1.2.1Mark Word例子解析圖

67行: 指向一個執行緒的顯示偏向鎖。

68行:一個匿名偏向鎖。

72行：輕量級鎖

73行：無鎖

74行：重量級鎖

75行：GC時使用

1.2.2 markOop中的列舉位解析：

基於上圖中的最後3位，下圖給出了列舉解釋。

我們稍加分析下幾個值：

5 == 101 就是上圖中的偏向鎖。

3 == 11 GC時使用。

2.偏向鎖

2.1偏向鎖的解釋： 

以下摘自《深入理解Java虛擬機器》，關於偏向鎖的理解，是有點複雜的，我先是把此書內的觀點摘抄下來，然後對比著理解。後續如果是藍色的字型就是摘抄的書中的原話。藉此來理解和分析。

當鎖物件第一次被執行緒獲取的時候，虛擬機器會把物件頭中的標誌位設定為01，即偏向模式。同時使用CAS操作把獲取到這個鎖的執行緒的ID記錄在物件的Mark Word中。如果操作成功，持有偏向鎖的執行緒以後每次進入這個鎖相關的同步塊時，虛擬機器都可以不再進行任何同步操作（例如，Locking，Unlocking，以及對Mark Word的update）。

當有另一個執行緒去嘗試獲取到這個鎖時，偏向模式就宣告結束。根據鎖物件目前是否處於被鎖定狀態，撤銷偏向後恢復到未鎖定狀態或升級為輕量級鎖定的狀態。

2.2偏向鎖的c++程式碼

2.2.1.此方法的入參：

1.1JavaThread（當前執行緒的值）

1.2BasicObjectLock基礎物件鎖（根據字面意思強行解釋一波）

1.2.1 BasicObjectLock結構如下：私有物件為 BasicLock 的例項 lock 和 oop 的例項 _obj。

class BasicObjectLock {
  BasicLock _lock; 
  // object holds the lock;
  oop  _obj;   
}
 

1.2.2 BasicLock主要儲存的是markoop物件，就是物件頭資料。

class BasicLock {
    volatile markOop _displaced_header;
}

2.2.2. 偏向鎖的流程獲取核心方法：fast_enter

在monitorenter程式碼中，可以看見如果開啟了偏向鎖的功能，那麼獲取的時候就進入了fast_enter流程。fast_enter就是這一篇主要分析的程式碼，或許理解的不夠，需要參考很多資料。此處我發現有兩個比較好的部落格，稍作記錄，兩篇部落格的觀點有點差別，具體還是見仁見智吧，因為關於fast_enter的cpp程式碼我也讀不懂~~~~~~~~~

解釋一：

1.偏向鎖的獲取：

2.偏向鎖的撤銷：

解釋二：

個人比較傾向解釋一的觀點，根據大致原始碼，發現解釋二中在判斷是否是偏向鎖的否流程中，原始碼呢看起來是傾向獲取輕量級鎖，但是此圖中確是去做CAS操作，這邊有點疑惑。。。

3.輕量級鎖的獲取和釋放

3.1原始碼簡單分析

void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
	//獲取mark word
  markOop mark = obj->mark();
  assert(!mark->has_bias_pattern(), "should not see bias pattern here");
  	
  if (mark->is_neutral()) {
	  //判斷是否是不可偏向狀態並且無鎖 0 01
    // Anticipate successful CAS -- the ST of the displaced mark must
    // be visible <= the ST performed by the CAS.
    lock->set_displaced_header(mark);  //將mark word寫入執行緒棧中的hdr中
	
    if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
	  //CAS 設定mark word指向hdr，保證只有一個執行緒能夠設定成功
      TEVENT (slow_enter: release stacklock) ;
      return ;
    }
    // Fall through to inflate() ...
  } else
  if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
	  //當前mark word指向本地執行緒棧，並且和當前執行緒一致，保證重入的特性
    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);
}

3.2必備理論知識

3.2.1輕量級鎖的獲取當中有個很重要的概念，即執行緒棧幀中的鎖記錄（Lock Record），下圖取自周志明-虛擬機器一書

3.2.2 Stack中hdr和Lock Record存在的幾個關鍵操作步驟如下圖：

操作1：虛擬機器會線上程棧幀中建立一個Lock Record，用於儲存鎖物件目前的Mark Word。

操作2：虛擬機器使用CAS操作嘗試將物件的Mark Word更新為指向Lock Record的指標。

操作3：如果CAS成功了，將owner執向Mark Word，代表了這個執行緒擁有了該物件的鎖。

3.2.3 基本流程分析

4.重量級鎖的膨脹

ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
  // Inflate mutates the heap ...
  // Relaxing assertion for bug 6320749.
  assert (Universe::verify_in_progress() ||
          !SafepointSynchronize::is_at_safepoint(), "invariant") ;

  for (;;) {   //自旋操作
      const markOop mark = object->mark() ;
      assert (!mark->has_bias_pattern(), "invariant") ;

      // The mark can be in one of the following states:
      // *  Inflated     - just return （膨脹完成）
      // *  Stack-locked - coerce it to inflated （輕量級鎖）
      // *  INFLATING    - busy wait for conversion to complete （膨脹中）
      // *  Neutral      - aggressively inflate the object. （無鎖）
      // *  BIASED       - Illegal.  We should never see this（偏向鎖）

      // CASE: inflated
      if (mark->has_monitor()) {
		  //如果是重量級鎖，直接返回
          ObjectMonitor * inf = mark->monitor() ;
          assert (inf->header()->is_neutral(), "invariant");
          assert (inf->object() == object, "invariant") ;
          assert (ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
          return inf ;
      }

      if (mark == markOopDesc::INFLATING()) {
		  //如果是膨脹中，自旋，等待膨脹完成
         TEVENT (Inflate: spin while INFLATING) ;
         ReadStableMark(object) ;
         continue ;
      }

      if (mark->has_locker()) {
          ObjectMonitor * m = omAlloc (Self) ;
          // Optimistically prepare the objectmonitor - anticipate successful CAS
          // We do this before the CAS in order to minimize the length of time
          // in which INFLATING appears in the mark.
		  
		  //如果當前是輕量級鎖，獲取自旋次數，驗證是否應該升級為重量級鎖
          m->Recycle();
          m->FreeNext      = NULL ;
          m->_Responsible  = NULL ;
          m->OwnerIsThread = 0 ;
          m->_recursions   = 0 ;
          m->_SpinDuration = Knob_SpinLimit ;   // Consider: maintain by type/class

          markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;
          if (cmp != mark) {
             omRelease (Self, m) ;
             continue ;       // Interference -- just retry
          }

          
          markOop dmw = mark->displaced_mark_helper() ;
          assert (dmw->is_neutral(), "invariant") ;

          // Setup monitor fields to proper values -- prepare the monitor
          m->set_header(dmw) ;

          // Optimization: if the mark->locker stack address is associated
          // with this thread we could simply set m->_owner = Self and
          // m->OwnerIsThread = 1.  Note that a thread can inflate an object
          // that it has stack-locked -- as might happen in wait() -- directly
          // with CAS.  That is, we can avoid the xchg-NULL .... ST idiom.
          m->set_owner (mark->locker());
          m->set_object(object);
          // TODO-FIXME: assert BasicLock->dhw != 0.

          // Must preserve store ordering. The monitor state must
          // be stable at the time of publishing the monitor address.
          guarantee (object->mark() == markOopDesc::INFLATING(), "invariant") ;
          object->release_set_mark(markOopDesc::encode(m));

          // Hopefully the performance counters are allocated on distinct cache lines
          // to avoid false sharing on MP systems ...
          if (_sync_Inflations != NULL) _sync_Inflations->inc() ;
          TEVENT(Inflate: overwrite stacklock) ;
          if (TraceMonitorInflation) {
            if (object->is_instance()) {
              ResourceMark rm;
              tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
                (intptr_t) object, (intptr_t) object->mark(),
                Klass::cast(object->klass())->external_name());
            }
          }
          return m ;
      }

      ...
}

重量級鎖的獲取和釋放，暫時沒有看懂，等後續看懂了再來書寫自己的理解吧