public synchronized void syncMethod();
  flags: ACC_PUBLIC, ACC_SYNCHRONIZED

0: new #2                  // 創(chuàng)建一個(gè)新的Object實(shí)例
3: dup
4: invokespecial #1        // 調(diào)用Object的構(gòu)造函數(shù)
7: astore_1                // 將引用存儲(chǔ)到局部變量1(lock)
8: aload_1                 // 將局部變量1(lock)加載到操作數(shù)棧
9: monitorenter            // 進(jìn)入monitor
10: ...                    // 同步塊體的字節(jié)碼
   : aload_1
   : monitorexit           // 退出monitor
   : ...

ObjectMonitor() {
    // 多線程競(jìng)爭(zhēng)鎖進(jìn)入時(shí)的單向鏈表
    ObjectWaiter * volatile _cxq;
    //處于等待鎖block狀態(tài)的線程，會(huì)被加入到該列表
    ObjectWaiter * volatile _EntryList;
    // _header是一個(gè)markOop類型，markOop就是對(duì)象頭中的Mark Word
    volatile markOop _header;
    // 搶占該鎖的線程數(shù)，約等于WaitSet.size + EntryList.size
    volatile intptr_t _count;
    // 等待線程數(shù)
    volatile intptr_t _waiters;
    // 鎖的重入次數(shù)
    volatile intptr_ _recursions;
    // 監(jiān)視器鎖寄生的對(duì)象，鎖是寄托存儲(chǔ)于對(duì)象中
    void* volatile  _object;
    // 指向持有ObjectMonitor對(duì)象的線程
    void* volatile _owner;
    // 處于wait狀態(tài)的線程，會(huì)被加入到_WaitSet
    ObjectWaiter * volatile _WaitSet;
    // 操作WaitSet鏈表的鎖
    volatile int _WaitSetLock;
    // 嵌套加鎖次數(shù)，最外層鎖的_recursions屬性為0
    volatile intptr_t  _recursions;
}

void ATTR ObjectMonitor::enter(TRAPS) {
  // The following code is ordered to check the most common cases first
  // and to reduce RTS->RTO cache line upgrades on SPARC and IA32 processors.
  Thread * const Self = THREAD ;
  void * cur ;
  // 無鎖CAS 轉(zhuǎn)為 偏向鎖
  cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
  if (cur == NULL) {
     // Either ASSERT _recursions == 0 or explicitly set _recursions = 0.
     assert (_recursions == 0   , "invariant") ;
     assert (_owner      == Self, "invariant") ;
     // CONSIDER: set or assert OwnerIsThread == 1
     return ;
  }
	// 可重入鎖
  if (cur == Self) {
     // TODO-FIXME: check for integer overflow!  BUGID 6557169.
     _recursions ++ ;
     return ;
  }
  if (Self->is_lock_owned ((address)cur)) {
    assert (_recursions == 0, "internal state error");
    _recursions = 1 ;
    // Commute owner from a thread-specific on-stack BasicLockObject address to
    // a full-fledged "Thread *".
    _owner = Self ;
    OwnerIsThread = 1 ;
    return ;
  }
  // We've encountered genuine contention.
  assert (Self->_Stalled == 0, "invariant") ;
  Self->_Stalled = intptr_t(this) ;
  // Try one round of spinning *before* enqueueing Self
  // and before going through the awkward and expensive state
  // transitions.  The following spin is strictly optional ...
  // Note that if we acquire the monitor from an initial spin
  // we forgo posting JVMTI events and firing DTRACE probes.
  // 自旋獲取鎖
  if (Knob_SpinEarly && TrySpin (Self) > 0) {
     assert (_owner == Self      , "invariant") ;
     assert (_recursions == 0    , "invariant") ;
     assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ;
     Self->_Stalled = 0 ;
     return ;
  }
  assert (_owner != Self          , "invariant") ;
  assert (_succ  != Self          , "invariant") ;
  assert (Self->is_Java_thread()  , "invariant") ;
  JavaThread * jt = (JavaThread *) Self ;
  assert (!SafepointSynchronize::is_at_safepoint(), "invariant") ;
  assert (jt->thread_state() != _thread_blocked   , "invariant") ;
  assert (this->object() != NULL  , "invariant") ;
  assert (_count >= 0, "invariant") ;
  // Prevent deflation at STW-time.  See deflate_idle_monitors() and is_busy().
  // Ensure the object-monitor relationship remains stable while there's contention.
  Atomic::inc_ptr(&_count);
  EventJavaMonitorEnter event;
  { // Change java thread status to indicate blocked on monitor enter.
    JavaThreadBlockedOnMonitorEnterState jtbmes(jt, this);
    DTRACE_MONITOR_PROBE(contended__enter, this, object(), jt);
    if (JvmtiExport::should_post_monitor_contended_enter()) {
      JvmtiExport::post_monitor_contended_enter(jt, this);
    }
    OSThreadContendState osts(Self->osthread());
    ThreadBlockInVM tbivm(jt);
    Self->set_current_pending_monitor(this);
    // TODO-FIXME: change the following for(;;) loop to straight-line code.
    for (;;) {
      jt->set_suspend_equivalent();
      // cleared by handle_special_suspend_equivalent_condition()
      // or java_suspend_self()
			// 重量級(jí)鎖
      EnterI (THREAD) ;
    省略.......
}

// 多核心多cpu前面就要加lock
#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "
inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
  return (intptr_t)cmpxchg((jlong)exchange_value, (volatile jlong*)dest, (jlong)compare_value);
}
inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value) {
  bool mp = os::is_MP();
  __asm__ __volatile__ (LOCK_IF_MP(%4) "cmpxchgq %1,(%3)"
                        : "=a" (exchange_value)
                        : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                        : "cc", "memory");
  return exchange_value;
}

  static volatile int greaterThanSevenCnt;
    descriptor: I
    flags: ACC_STATIC, ACC_VOLATILE

CASE(_putfield):
CASE(_putstatic):
    {
          // .... 省略若干行 
          // ....
          // Now store the result 現(xiàn)在要開始存儲(chǔ)結(jié)果了
          // ConstantPoolCacheEntry* cache;     -- cache是常量池緩存實(shí)例
          // cache->is_volatile()               -- 判斷是否有volatile訪問標(biāo)志修飾
          int field_offset = cache->f2_as_index();
          if (cache->is_volatile()) { // ****重點(diǎn)判斷邏輯**** 
            // volatile變量的賦值邏輯
            if (tos_type == itos) {
              obj->release_int_field_put(field_offset, STACK_INT(-1));
            } else if (tos_type == atos) {// 對(duì)象類型賦值
              VERIFY_OOP(STACK_OBJECT(-1));
              obj->release_obj_field_put(field_offset, STACK_OBJECT(-1));
              OrderAccess::release_store(&BYTE_MAP_BASE[(uintptr_t)obj >> CardTableModRefBS::card_shift], 0);
            } else if (tos_type == btos) {// byte類型賦值
              obj->release_byte_field_put(field_offset, STACK_INT(-1));
            } else if (tos_type == ltos) {// long類型賦值
              obj->release_long_field_put(field_offset, STACK_LONG(-1));
            } else if (tos_type == ctos) {// char類型賦值
              obj->release_char_field_put(field_offset, STACK_INT(-1));
            } else if (tos_type == stos) {// short類型賦值
              obj->release_short_field_put(field_offset, STACK_INT(-1));
            } else if (tos_type == ftos) {// float類型賦值
              obj->release_float_field_put(field_offset, STACK_FLOAT(-1));
            } else {// double類型賦值
              obj->release_double_field_put(field_offset, STACK_DOUBLE(-1));
            }
            // *** 寫完值后的storeload屏障 ***
            OrderAccess::storeload();
          } else {
            // 非volatile變量的賦值邏輯
            if (tos_type == itos) {
              obj->int_field_put(field_offset, STACK_INT(-1));
            } else if (tos_type == atos) {
              VERIFY_OOP(STACK_OBJECT(-1));
              obj->obj_field_put(field_offset, STACK_OBJECT(-1));
              OrderAccess::release_store(&BYTE_MAP_BASE[(uintptr_t)obj >> CardTableModRefBS::card_shift], 0);
            } else if (tos_type == btos) {
              obj->byte_field_put(field_offset, STACK_INT(-1));
            } else if (tos_type == ltos) {
              obj->long_field_put(field_offset, STACK_LONG(-1));
            } else if (tos_type == ctos) {
              obj->char_field_put(field_offset, STACK_INT(-1));
            } else if (tos_type == stos) {
              obj->short_field_put(field_offset, STACK_INT(-1));
            } else if (tos_type == ftos) {
              obj->float_field_put(field_offset, STACK_FLOAT(-1));
            } else {
              obj->double_field_put(field_offset, STACK_DOUBLE(-1));
            }
          }
          UPDATE_PC_AND_TOS_AND_CONTINUE(3, count);
  }

inline void OrderAccess::storeload()  { fence(); }
inline void OrderAccess::fence() {
  if (os::is_MP()) {
    // always use locked addl since mfence is sometimes expensive
#ifdef AMD64
    __asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", "memory");
#else
    __asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", "memory");
#endif
  }
}

cas volatile變量開始鎖定
任意程序代碼
cas volatile變量釋放鎖定