在Java中任何一个对象都有一个Monitor（可以认为是一个对象）与之关联，因为在Java的设计中 ，每一个Java对象被创建出来就带了一把看不见的锁，它叫做内部锁或者Monitor锁，也就是通常说Synchronized的对象锁，当且一个Monitor被持有后，它将处于锁定状态，监视器锁的实现依赖底层操作系统的Mutex互斥量（这是一种基于操作系统的重量级锁）。那么这个Monitor到底是什么？

在Hotspot中定义了一个ObjectMonitor结构：

  1. ObjectMonitor::ObjectMonitor() {  
  2.   _header       = NULL;  
  3.   _count        = 0;  
  4.   _waiters      = 0,  
  5.   _recursions   = 0;       //线程的重入次数
  6.   _object       = NULL;  
  7.   _owner        = NULL;    //标识拥有该monitor的线程
  8.   _WaitSet      = NULL;    //处于wait状态的线程，会被加入到_WaitSet队列
  9.   _WaitSetLock  = 0 ;  
  10.   _Responsible  = NULL ;  
  11.   _succ         = NULL ;  
  12.   _cxq          = NULL ;    //维护着最新参与竞争的线程，也可以争夺锁资源
  13.   FreeNext      = NULL ;  
  14.   _EntryList    = NULL ;    //处于等待锁block状态的线程，会被加入到该列表，等待所释放争夺锁资源
  15.   _SpinFreq     = 0 ;  
  16.   _SpinClock    = 0 ;  
  17.   OwnerIsThread = 0 ;  
  18. }

_WaitSet：当获得Monitor的线程调用 wait() 方法，将释放当前持有的monitor，owner变量恢复为null，count自减1，同时将该线程封装成ObjectWaiter对象进入WaitSet 集合中等待被唤醒
_EntryList：Monitor已被其他线程获取，需要争夺锁的线程就进入_EntryList，等待锁释放再去争夺锁资源
_cxq：维护着最新参与竞争的线程，也可以争夺锁资源

enter()

通过该方法，开始获取重量级锁

  1. 如果当前Monitor的owner为null，通过CAS可直接获取
  2. 如果当前Monitor的owner是当前线程，则 _recursions 自增，记录重入次数
  3. 如果当前线程获取了轻量级锁，可以直接获取Monitor
  4. 如果Monitor对象已被获取，则尝试自旋获取锁资源
  5. 自旋获取锁失败，将当前线程状态设为 BLOCKED_ON_MONITOR_ENTER
  6. 进入 EnterI() 方法， 再次自旋获取锁
  7. 获取锁失败后，将对象封装为ObjectWaiter，CAS放入_cxq队列（放入失败再次自旋获取锁）

  8. 在阻塞前再次自旋获取锁，若失败后才阻塞线程 ```java void ATTR ObjectMonitor::enter(TRAPS) { //获取当前线程指针 Thread const Self = THREAD ; void cur ;

    //CAS设置owner属性，如果_owner属性是NULL就将其设置为Self，否则返回当前的_owner属性 cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ; if (cur == NULL) { //设置成功，说明该Monitor没有被人占用 assert (_recursions == 0 , “invariant”) ; assert (_owner == Self, “invariant”) ; // CONSIDER: set or assert OwnerIsThread == 1 return ; } //如果_owner就是当前线程 if (cur == Self) { //设置失败，说明该Monitor就是当前线程占用的，此处进入enter是嵌套加锁情形 _recursions ++ ; return ; }

    //轻量级锁膨胀成重量级锁时，将owner设置为当前线程，直接返回 if (Self->is_lock_owned ((address)cur)) {
    assert (_recursions == 0, “internal state error”); //正常轻量级膨胀成重量级锁时，之前已经获取轻量级锁的线程不需要二次调用enter方法 //此时再调用enter方法说明是锁嵌套情形，将_recursions置为1 _recursions = 1 ; //将owner置为当前线程 _owner = Self ; //表明当前线程是获取轻量级锁的 OwnerIsThread = 1 ; return ; }

    //该Monitor被其他某个线程占用了，需要抢占 assert (Self->_Stalled == 0, “invariant”) ; //记录需要抢占的Monitor指针 Self->_Stalled = intptr_t(this) ;

    //Knob_SpinEarly默认为1，即为true //TrySpin让当前线程自旋，自旋的次数默认可以自适应调整，如果进入安全点同步则退出自旋，返回1表示抢占成功 if (Knob_SpinEarly && TrySpin (Self) > 0) { assert (_owner == Self , “invariant”) ; assert (_recursions == 0 , “invariant”) ; assert (((oop)(object()))->mark() == markOopDesc::encode(this), “invariant”) ; //将_Stalled置为NULL 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”) ;

    //原子的将_count属性加1，表示增加了一个抢占该锁的线程 Atomic::inc_ptr(&_count);

    EventJavaMonitorEnter event;

    { //修改Java线程状态为BLOCKED_ON_MONITOR_ENTER，此代码块退出后还原成原来的 JavaThreadBlockedOnMonitorEnterState jtbmes(jt, this);

    Self->set_current_pending_monitor(this);

    DTRACE_MONITOR_PROBE(contended__enter, this, object(), jt); if (JvmtiExport::should_post_monitor_contended_enter()) { JvmtiExport::post_monitor_contended_enter(jt, this); }

    //修改OS线程状态为MONITOR_WAIT，此代码块退出后还原成原来的 OSThreadContendState osts(Self->osthread()); //让当前线程的调用栈帧可以walkable，即可以被遍历，需要记录上一次执行的Java字节码 //然后切换线程的运行状态，从_thread_in_vm切换成_thread_blocked，切换的过程如果进入安全点同步则会被阻塞，此代码块退出将状态从_thread_blocked切换成_thread_in_vm，同样切换过程中如果进入安全点同步则被阻塞 ThreadBlockInVM tbivm(jt);

    // TODO-FIXME: change the following for(;;) loop to straight-line code. for (;;) { //将线程的_suspend_equivalent属性置为true，该属性表明当前线程处于悬浮状态 jt->set_suspend_equivalent();

    //会通过自旋，park等方式不断循环尝试获取锁，直到成功获取锁为止 EnterI (THREAD) ;

    //ExitSuspendEquivalent默认返回false if (!ExitSuspendEquivalent(jt)) break ;

    // 等待suspended当前线程的线程

    1.    _recursions = 0 ;

    _succ = NULL ; exit (false, Self) ;

    jt->java_suspend_self(); } //将关联的ObjectMonitor置为null，表示当前线程已经不在阻塞状态了 Self->set_current_pending_monitor(NULL); }

    //原子的将count属性减1，表示已经有一个线程成功获取锁 Atomic::dec_ptr(&_count); assert (_count >= 0, “invariant”) ; Self->_Stalled = 0 ;

    // Must either set _recursions = 0 or ASSERT _recursions == 0. assert (_recursions == 0 , “invariant”) ; assert (_owner == Self , “invariant”) ; assert (_succ != Self , “invariant”) ; assert (((oop)(object()))->mark() == markOopDesc::encode(this), “invariant”) ;

    DTRACE_MONITOR_PROBE(contended__entered, this, object(), jt); if (JvmtiExport::should_post_monitor_contended_entered()) { JvmtiExport::post_monitor_contended_entered(jt, this); }

    if (event.should_commit()) { event.set_klass(((oop)this->object())->klass()); event.set_previousOwner((TYPE_JAVALANGTHREAD)_previous_owner_tid); event.set_address((TYPE_ADDRESS)(uintptr_t)(this->object_addr())); event.commit(); }

    if (ObjectMonitor::_sync_ContendedLockAttempts != NULL) { //增加计数 ObjectMonitor::_sync_ContendedLockAttempts->inc() ; } }

void ATTR ObjectMonitor::EnterI (TRAPS) { Thread Self = THREAD ; assert (Self->is_Java_thread(), “invariant”) ; //校验线程状态已经处于阻塞中 assert (((JavaThread ) Self)->thread_state() == _thread_blocked , “invariant”) ;

  1. if (TryLock (Self) > 0) {
  2.     //尝试获取锁，获取成功则返回
  3.     assert (_succ != Self              , "invariant") ;
  4.     assert (_owner == Self             , "invariant") ;
  5.     assert (_Responsible != Self       , "invariant") ;
  6.     return ;
  7. }
  9. //初始化自旋相关配置参数
  10. DeferredInitialize () ;
  12. if (TrySpin (Self) > 0) {
  13.     //再次尝试自旋，获取锁成功则返回
  14.     assert (_owner == Self        , "invariant") ;
  15.     assert (_succ != Self         , "invariant") ;
  16.     assert (_Responsible != Self  , "invariant") ;
  17.     return ;
  18. }
  20. //自旋获取锁失败，将当前线程加入到等待队列中并且park
  21. assert (_succ  != Self            , "invariant") ;
  22. assert (_owner != Self            , "invariant") ;
  23. assert (_Responsible != Self      , "invariant") ;
  26. //创建一个ObjectWaiter并初始化
  27. ObjectWaiter node(Self) ;
  28. Self->_ParkEvent->reset() ;
  29. node._prev   = (ObjectWaiter *) 0xBAD ;
  30. node.TState  = ObjectWaiter::TS_CXQ ;
  32. ObjectWaiter * nxt ;
  33. for (;;) {
  34.     node._next = nxt = _cxq ;
  35.     //原子的修改_cxq为node，如果修改成功则终止循环，表示已经成功加入到链表中
  36.     if (Atomic::cmpxchg_ptr (&node, &_cxq, nxt) == nxt) 
  37.         break ;
  39.     //修改失败，某个线程改变了cxq
  40.     if (TryLock (Self) > 0) {
  41.         //再次尝试获取锁，获取成功则返回
  42.         assert (_succ != Self         , "invariant") ;
  43.         assert (_owner == Self        , "invariant") ;
  44.         assert (_Responsible != Self  , "invariant") ;
  45.         return ;
  46.     }
  47. }
  49. //SyncFlags对的默认值是0
  50. if ((SyncFlags & 16) == 0 && nxt == NULL && _EntryList == NULL) {
  51.     //nxt或者_EntryList为NULL，说明当前线程是第一个阻塞的线程，将_Responsible原子的修改为当前线程
  52.     Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
  53. }
  55. TEVENT (Inflated enter - Contention) ;
  56. int nWakeups = 0 ;
  57. int RecheckInterval = 1 ;
  59. for (;;) {
  60.     //尝试获取锁
  61.     if (TryLock (Self) > 0) break ;
  62.     assert (_owner != Self, "invariant") ;
  64.     if ((SyncFlags & 2) && _Responsible == NULL) {
  65.        //原子的将_Responsible置为Self
  66.        Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
  67.     }
  69.     //将目标线程park掉，底层通过操作系统的互斥量实现，让当前线程休眠
  70.     if (_Responsible == Self || (SyncFlags & 1)) {
  71.         TEVENT (Inflated enter - park TIMED) ;
  72.         Self->_ParkEvent->park ((jlong) RecheckInterval) ;
  73.         //增加等待时间，最大不超过1s
  74.         RecheckInterval *= 8 ;
  75.         if (RecheckInterval > 1000) RecheckInterval = 1000 ;
  76.     } else {
  77.         TEVENT (Inflated enter - park UNTIMED) ;
  78.         Self->_ParkEvent->park() ;
  79.     }
  81.     //线程被唤醒了，即某个占用锁的线程释放了锁，尝试抢占该锁
  82.     if (TryLock(Self) > 0) 
  83.         break ;
  86.     TEVENT (Inflated enter - Futile wakeup) ;
  87.     if (ObjectMonitor::_sync_FutileWakeups != NULL) {
  88.        //增加计数
  89.        ObjectMonitor::_sync_FutileWakeups->inc() ;
  90.     }
  91.     //增加计数
  92.     ++ nWakeups ;
  94.     //Knob_SpinAfterFutile默认值是1，此时会再次尝试自旋获取锁
  95.     if ((Knob_SpinAfterFutile & 1) && TrySpin (Self) > 0) break ;
  97.     //Knob_ResetEvent默认值是0
  98.     if ((Knob_ResetEvent & 1) && Self->_ParkEvent->fired()) {
  99.        Self->_ParkEvent->reset() ;
  100.        OrderAccess::fence() ;
  101.     }
  102.     if (_succ == Self) _succ = NULL ;
  104.     //强制所有修改立即生效
  105.     OrderAccess::fence() ;
  106. }
  108. //for循环结束，当前线程已经获取了锁
  109. assert (_owner == Self      , "invariant") ;
  110. assert (object() != NULL    , "invariant") ;
  112. //将其从EntryList或者cxq链表中移除
  113. UnlinkAfterAcquire (Self, &node) ;
  114. if (_succ == Self) _succ = NULL ;
  116. assert (_succ != Self, "invariant") ;
  117. if (_Responsible == Self) {
  118.     //将_Responsible置为NULL
  119.     _Responsible = NULL ;
  120.     OrderAccess::fence(); // Dekker pivot-point
  121. }
  123. if (SyncFlags & 8) {
  124.    OrderAccess::fence() ;
  125. }
  126. return ;

}

  2. <a name="ZmgJ1"></a>
  3. # exit()
  4. 调用exit()，释放锁资源，让自旋状态的线程参与锁争夺或唤醒阻塞的线程
  6. 1. 如果 _recursions 不为0，则说明有重入，只需将_recursions 自减并返回
  7. 1. Knob_ExitPolicy == 0 (默认) 释放锁资源，此时处于自旋状态的线程可以获取锁，若_cxq/EntryList不为空，后续**再次抢占锁**，**若失败则说明自旋状态的线程抢锁成功**，直接返回。（该**策略保证自旋状态的线程优先获取锁**）
  8. 1. Knob_ExitPolicy == 2 唤醒cxq队列中的线程并返回
  9. 1. Knob_ExitPolicy == 3 拿出_cxq队列中的所有元素，逐个放到_EntryList队列的**尾部**，构成新的双向链表，把_cxq队列置为null
  10. 1. Knob_ExitPolicy == 4 拿出_cxq队列中的所有元素，逐个放到_EntryList队列的**头部**，构成新的双向链表，并把_cxq队列置为null
  11. 1. 如果_EntryList不为空，唤醒_EntryList中的线程，直接返回。
  12. 1. _EntryList为空，若Knob_ExitPolicy == 1，将_cxq中的元素的顺序倒转，放入_EntryList中，构成新的双向链表。若Knob_ExitPolicy != 1，则说明是Knob_ExitPolicy ==0的时候释放锁失败(没有自旋线程抢锁，释放了锁有被当前线程抢回来)，则之间把_cxq队列的元素放到_EntryList中
  13. 1. 唤醒_EntryList中的线程
  14. ```java
  15. void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) {
  16.    Thread * Self = THREAD ;
  17.    if (THREAD != _owner) {
  18.      if (THREAD->is_lock_owned((address) _owner)) {
  19.        //如果owner位于当前线程调用栈帧，说明该锁是轻量级锁膨胀来的
  20.        assert (_recursions == 0, "invariant") ;
  21.        //修改owner属性
  22.        _owner = THREAD ;
  23.        _recursions = 0 ;
  24.        OwnerIsThread = 1 ;
  25.      } else {
  26.        //其他线程占用该锁，直接返回
  27.        TEVENT (Exit - Throw IMSX) ;
  28.        assert(false, "Non-balanced monitor enter/exit!");
  29.        if (false) {
  30.           THROW(vmSymbols::java_lang_IllegalMonitorStateException());
  31.        }
  32.        return;
  33.      }
  34.    }
  36.    if (_recursions != 0) {
  37.      //不等于0说明是嵌套加锁，将_recursions减1即可返回
  38.      _recursions--;        // this is simple recursive enter
  39.      TEVENT (Inflated exit - recursive) ;
  40.      return ;
  41.    }
  43.    // SyncFlags默认值是0
  44.    if ((SyncFlags & 4) == 0) {
  45.       _Responsible = NULL ;
  46.    }
  48.    for (;;) {
  49.       assert (THREAD == _owner, "invariant") ;
  51.       //Knob_ExitPolicy默认值是0
  52.       if (Knob_ExitPolicy == 0) {
  53.          //将_owner属性置为NULL，释放锁，如果某个线程正在自旋抢占该锁，则会抢占成功
  54.          //即这种策略会优先保证通过自旋抢占锁的线程获取锁，而其他处于等待队列中的线程则靠后
  55.          OrderAccess::release_store_ptr (&_owner, NULL) ;   // drop the lock
  56.          //让修改立即生效
  57.          OrderAccess::storeload() ;                         // See if we need to wake a successor
  58.          if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
  59.             //如果_EntryList或者cxq链表是空的，则直接返回
  60.             TEVENT (Inflated exit - simple egress) ;
  61.             return ;
  62.          }
  63.          TEVENT (Inflated exit - complex egress) ;
  65.          //如果_EntryList或者cxq链表不是空的，则原子的设置owner属性为当前线程，尝试抢占锁
  66.          if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
  67.             //抢占失败则返回，等占用该锁的线程释放后再处理链表中的等待线程
  68.             return ;
  69.          }
  70.          TEVENT (Exit - Reacquired) ;
  71.       } else {
  72.          if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
  73.             OrderAccess::release_store_ptr (&_owner, NULL) ;   // drop the lock
  74.             OrderAccess::storeload() ;
  75.             // Ratify the previously observed values.
  76.             if (_cxq == NULL || _succ != NULL) {
  77.                 TEVENT (Inflated exit - simple egress) ;
  78.                 return ;
  79.             }
  80.             //有可能cxq插入了一个新节点，导致上面的if不成立，需要重新获取锁
  81.             if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
  82.                TEVENT (Inflated exit - reacquired succeeded) ;
  83.                return ;
  84.             }
  85.             TEVENT (Inflated exit - reacquired failed) ;
  86.          } else {
  87.             //如果_EntryList或者cxq链表不是空的则不释放锁，避免二次抢占锁，即优先处理等待队列中的线程
  88.             TEVENT (Inflated exit - complex egress) ;
  89.          }
  90.       }
  92.       guarantee (_owner == THREAD, "invariant") ;
  94.       ObjectWaiter * w = NULL ;
  95.       //Knob_QMode的默认值是0
  96.       int QMode = Knob_QMode ;
  98.       if (QMode == 2 && _cxq != NULL) {
  99.           w = _cxq ;
  100.           assert (w != NULL, "invariant") ;
  101.           assert (w->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
  102.           //通过unpark唤醒cxq对应的线程，唤醒后会将cxq从链表中移除
  103.           ExitEpilog (Self, w) ;
  104.           return ;
  105.       }
  107.       if (QMode == 3 && _cxq != NULL) {
  108.           //将cxq链表中的元素插入到_EntryList链表的末尾
  109.           w = _cxq ;
  110.           for (;;) {
  111.              assert (w != NULL, "Invariant") ;
  112.              //将_cxq原子的置为NULL，如果失败则更新w，重新尝试直到成功为止
  113.              //置为NULL后，如果有新的节点插入进来就形成了一个新的cxq链表
  114.              ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
  115.              if (u == w) break ;
  116.              w = u ;
  117.           }
  118.           assert (w != NULL              , "invariant") ;
  120.           ObjectWaiter * q = NULL ;
  121.           ObjectWaiter * p ;
  122.           //遍历cxq中的所有节点，将其置为TS_ENTER，并构成一个双向链表
  123.           for (p = w ; p != NULL ; p = p->_next) {
  124.               guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
  125.               p->TState = ObjectWaiter::TS_ENTER ;
  126.               p->_prev = q ;
  127.               q = p ;
  128.           }
  130.           ObjectWaiter * Tail ;
  131.           //遍历_EntryList找到末尾元素，将w插入到后面
  132.           for (Tail = _EntryList ; Tail != NULL && Tail->_next != NULL ; Tail = Tail->_next) ;
  133.           if (Tail == NULL) {
  134.               _EntryList = w ;
  135.           } else {
  136.               Tail->_next = w ;
  137.               w->_prev = Tail ;
  138.           }
  139.       }
  141.       if (QMode == 4 && _cxq != NULL) {
  142.           //将cxq链表中的元素插入到_EntryList链表的头部
  143.           w = _cxq ;
  144.           for (;;) {
  145.              assert (w != NULL, "Invariant") ;
  146.              //将_cxq原子的置为NULL，如果失败则更新w，重新尝试直到成功为止
  147.              ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
  148.              if (u == w) break ;
  149.              w = u ;
  150.           }
  151.           assert (w != NULL              , "invariant") ;
  153.           ObjectWaiter * q = NULL ;
  154.           ObjectWaiter * p ;
  155.           //遍历cxq中的所有节点，将其置为TS_ENTER，并构成一个双向链表
  156.           for (p = w ; p != NULL ; p = p->_next) {
  157.               guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
  158.               p->TState = ObjectWaiter::TS_ENTER ;
  159.               //构成双向链表
  160.               p->_prev = q ;
  161.               q = p ;
  162.           }
  164.           //插入到_EntryList的头部
  165.           if (_EntryList != NULL) {
  166.               q->_next = _EntryList ;
  167.               _EntryList->_prev = q ;
  168.           }
  169.           _EntryList = w ;
  171.       }
  173.       //如果_EntryList不为空
  174.       w = _EntryList  ;
  175.       if (w != NULL) {
  176.           //通过unpark唤醒w对应的线程，唤醒后会该线程会负责将w从EntryList链表中移除
  177.           assert (w->TState == ObjectWaiter::TS_ENTER, "invariant") ;
  178.           ExitEpilog (Self, w) ;
  179.           return ;
  180.       }
  182.       w = _cxq ;
  183.       if (w == NULL) continue ;//如果cxq为空则重新循环，不会进入此分支
  185.       //cxq不为NULL
  186.       for (;;) {
  187.           assert (w != NULL, "Invariant") ;
  188.           //将cxq原子的修改为NULL
  189.           ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
  190.           if (u == w) break ;
  191.           w = u ;
  192.       }
  193.       TEVENT (Inflated exit - drain cxq into EntryList) ;
  195.       assert (w != NULL              , "invariant") ;
  196.       assert (_EntryList  == NULL    , "invariant") ;
  198.       if (QMode == 1) {
  199.          //遍历cxq中的元素将其加入到_EntryList中，注意顺序跟cxq中是反的
  200.          ObjectWaiter * s = NULL ;
  201.          ObjectWaiter * t = w ;
  202.          ObjectWaiter * u = NULL ;
  203.          while (t != NULL) {
  204.              guarantee (t->TState == ObjectWaiter::TS_CXQ, "invariant") ;
  205.              t->TState = ObjectWaiter::TS_ENTER ;
  206.              u = t->_next ;
  207.              t->_prev = u ;
  208.              t->_next = s ;
  209.              s = t;
  210.              t = u ;
  211.          }
  212.          _EntryList  = s ;
  213.          assert (s != NULL, "invariant") ;
  214.       } else {
  215.          // QMode == 0 or QMode == 2
  216.          //遍历cxq中的元素将其加入到_EntryList中，注意此时cxq链表的头元素被赋值给EntryList
  217.          _EntryList = w ;
  218.          ObjectWaiter * q = NULL ;
  219.          ObjectWaiter * p ;
  220.          //cxq中的元素是通过next属性串联起来的，prev属性没有，此处遍历加上prev属性
  221.          //当EntryList头元素被移除了是取next属性作为EntryList
  222.          for (p = w ; p != NULL ; p = p->_next) {
  223.              guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
  224.              p->TState = ObjectWaiter::TS_ENTER ;
  225.              p->_prev = q ;
  226.              q = p ;
  227.          }
  228.       }
  230.       if (_succ != NULL) continue;
  232.       w = _EntryList  ;
  233.       if (w != NULL) {
  234.           guarantee (w->TState == ObjectWaiter::TS_ENTER, "invariant") ;
  235.           //唤醒w对应的线程
  236.           ExitEpilog (Self, w) ;
  237.           return ;
  238.       }
  239.    }
  240. }

wait()

  1. 检查中断状态，如果被中断则抛出异常，java_lang_InterruptedException()
  2. 封装ObjectWaiter对象，加入到_WaitSet中，并释放Monitor
  3. 再次检查中断状态和有无被notify，没有调用park方法将线程挂起

  4. 线程被唤醒，从_WaitSet中移除，再次争夺锁资源，抢到锁后wait方法退出。 ```java void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) { Thread const Self = THREAD; JavaThread jt = (JavaThread *)THREAD; EventJavaMonitorWait event; // 检查中断状态 if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) { //抛出异常 THROW(vmSymbols::java_lang_InterruptedException()); return; } //关联线程 Self->_Stalled = intptr_t(this); jt->set_current_waiting_monitor(this); //新建节点 ObjectWaiter node(Self); node.TState = ObjectWaiter::TS_WAIT; Self->_ParkEvent->reset(); OrderAccess::fence(); // ST into Event; membar ; LD interrupted-flag //CAS自旋给WaitSet加锁 Thread::SpinAcquire(&_WaitSetLock, “WaitSet - add”); //加入WaitSet等待队列 AddWaiter(&node); //CAS自旋给WaitSet释放锁 Thread::SpinRelease(&_WaitSetLock);

    intptr_t save = _recursions; // record the old recursion count _waiters++; // increment the number of waiters _recursions = 0; // 记录线程重入次数 //当前线程从监视器退出，MonitorExit exit(true, Self);

    int ret = OS_OK; int WasNotified = 0; { // State transition wrappers OSThread* osthread = Self->osthread(); OSThreadWaitState osts(osthread, true); { ThreadBlockInVM tbivm(jt); // Thread is in thread_blocked state and oop access is unsafe. jt->set_suspend_equivalent(); //检查是否中断 if (interruptible && (Thread::is_interrupted(THREAD, false) || HAS_PENDING_EXCEPTION)) {

    1.  // Intentionally empty

    } else if (node._notified == 0) { //未被notify通知

    1.  if (millis <= 0) {
    2.    Self->_ParkEvent->park(); //将线程挂起
    3.  } else {
    4.    ret = Self->_ParkEvent->park(millis); //挂起指定时间
    5.  }

    } // were we externally suspended while we were waiting? if (ExitSuspendEquivalent (jt)) {

    1.  // TODO-FIXME: add -- if succ == Self then succ = null.
    2.  jt->java_suspend_self();

    }

    } // Exit thread safepoint: transition _thread_blocked -> _thread_in_vm

    //双重加锁检查，如果已在WaitSet则从WaitSet移除 if (node.TState == ObjectWaiter::TS_WAIT) { Thread::SpinAcquire(&_WaitSetLock, “WaitSet - unlink”); if (node.TState == ObjectWaiter::TS_WAIT) {

    1.  //从队列移除
    2.  DequeueSpecificWaiter(&node);       // unlink from WaitSet
    3.  node.TState = ObjectWaiter::TS_RUN;

    } Thread::SpinRelease(&_WaitSetLock); }

    OrderAccess::loadload(); if (_succ == Self) _succ = NULL; WasNotified = node._notified; //如果处于被唤醒状态重新抢占锁 OrderAccess::fence(); Self->_Stalled = 0; ObjectWaiter::TStates v = node.TState; if (v == ObjectWaiter::TS_RUN) { enter(Self); } else { ReenterI(Self, &node); //重入 node.wait_reenter_end(this); } } // OSThreadWaitState()

    jt->set_current_waiting_monitor(NULL); _recursions = save; // restore the old recursion count _waiters—; // decrement the number of waiters

}

  2. <a name="h5yiu"></a>
  3. # notify()
  4. 根据不同的policy，对**_WaitSet中的头节**点进行不同操作进行不同
  6. 1. policy = 0，将该节点放入 _EntryList头部。
  7. 1. policy = 1，将该节点放入 _EntryList尾部。
  8. 1. policy = 2，将该节点放入 _cqx头部。
  9. 1. policy = 3，将该节点放入 _cqx尾部。
  10. 1. policy = 4，直接将线程唤醒。
  11. ```java
  12. void ObjectMonitor::INotify(Thread * Self) {
  13.   const int policy = Knob_MoveNotifyee;
  14.   //锁住队列
  15.   Thread::SpinAcquire(&_WaitSetLock, "WaitSet - notify");
  16.     //得到_WaitSet中第一个节点
  17.   ObjectWaiter * iterator = DequeueWaiter();
  18.   if (iterator != NULL) {
  19.     if (policy != 4) { //将状态置为TS_ENTER
  20.       iterator->TState = ObjectWaiter::TS_ENTER;
  21.     }
  22.     iterator->_notified = 1; //标记为被唤醒
  23.     iterator->_notifier_tid = THREAD_TRACE_ID(Self);
  24.     ObjectWaiter * list = _EntryList;
  25.     if (policy == 0) {       //放到EntryList头部
  26.       if (list == NULL) {
  27.         iterator->_next = iterator->_prev = NULL;
  28.         _EntryList = iterator;
  29.       } else {
  30.         list->_prev = iterator;
  31.         iterator->_next = list;
  32.         iterator->_prev = NULL;
  33.         _EntryList = iterator;
  34.       }
  35.     } else if (policy == 1) {      //放到EntryList尾部
  36.       if (list == NULL) {
  37.         iterator->_next = iterator->_prev = NULL;
  38.         _EntryList = iterator;
  39.       } else {
  40.         ObjectWaiter * tail;
  41.         for (tail = list; tail->_next != NULL; tail = tail->_next) /* empty */;
  42.         assert(tail != NULL && tail->_next == NULL, "invariant");
  43.         tail->_next = iterator;
  44.         iterator->_prev = tail;
  45.         iterator->_next = NULL;
  46.       }
  47.     } else if (policy == 2) {      // 放到cxq头部
  48.       if (list == NULL) {
  49.         iterator->_next = iterator->_prev = NULL;
  50.         _EntryList = iterator;
  51.       } else {
  52.         iterator->TState = ObjectWaiter::TS_CXQ;
  53.         for (;;) {
  54.           ObjectWaiter * front = _cxq;
  55.           iterator->_next = front;
  56.           if (Atomic::cmpxchg_ptr(iterator, &_cxq, front) == front) {
  57.             break;
  58.           }
  59.         }
  60.       }
  61.     } else if (policy == 3) {      // 放到cxq尾部
  62.       iterator->TState = ObjectWaiter::TS_CXQ;
  63.       for (;;) {
  64.         ObjectWaiter * tail = _cxq;
  65.         if (tail == NULL) {
  66.           iterator->_next = NULL;
  67.           if (Atomic::cmpxchg_ptr(iterator, &_cxq, NULL) == NULL) {
  68.             break;
  69.           }
  70.         } else {
  71.           while (tail->_next != NULL) tail = tail->_next;
  72.           tail->_next = iterator;
  73.           iterator->_prev = tail;
  74.           iterator->_next = NULL;
  75.           break;
  76.         }
  77.       }
  78.     } else { //唤醒
  79.       ParkEvent * ev = iterator->_event;
  80.       iterator->TState = ObjectWaiter::TS_RUN;
  81.       OrderAccess::fence();
  82.       ev->unpark();
  83.     }
  84.     if (policy < 4) {
  85.      //修改线程状态，记录锁竞争开始
  86.       iterator->wait_reenter_begin(this);
  87.     }
  88.   }
  89.   Thread::SpinRelease(&_WaitSetLock);
  90. }

微信截图_20210630110144.png

锁的膨胀

上面这些方法只有重量级锁状态才能调用，如果当前对象非重量级锁调用了上述方法，会调用 inflate() 方法直接膨胀为重量级锁。

  1. ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
  2.   // Inflate mutates the heap ...
  3.   // Relaxing assertion for bug 6320749.
  4.   assert (Universe::verify_in_progress() ||
  5.           !SafepointSynchronize::is_at_safepoint(), "invariant") ;
  7.   for (;;) {
  8.       //获取对象的 Mark Word
  9.       const markOop mark = object->mark() ;
  10.       //确保当前对象非偏向锁状态
  11.       assert (!mark->has_bias_pattern(), "invariant") ;
  13.       // The mark can be in one of the following states:  对象Mark Word有一下几种状态
  14.       // *  Inflated     - just return                            重量级锁状态
  15.       // *  Stack-locked - coerce it to inflated                轻量级锁状态
  16.       // *  INFLATING    - busy wait for conversion to complete 正在膨胀为重量级锁中
  17.       // *  Neutral      - aggressively inflate the object.        无锁状态
  18.       // *  BIASED       - Illegal.  We should never see this    偏向状态(在该方法中不允许出现)
  20.       // CASE: inflated 当处于重量级锁状态，直接返回
  21.       if (mark->has_monitor()) {
  22.           ObjectMonitor * inf = mark->monitor() ;
  23.           assert (inf->header()->is_neutral(), "invariant");
  24.           assert (inf->object() == object, "invariant") ;
  25.           assert (ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
  26.           return inf ;
  27.       }
  29.       // 处于膨胀中
  30.       if (mark == markOopDesc::INFLATING()) {
  31.          TEVENT (Inflate: spin while INFLATING) ;
  32.          ReadStableMark(object) ;
  33.          continue ;
  34.       }
  36.       // CASE: stack-locked 处于轻量级锁中
  37.       if (mark->has_locker()) {
  38.           ObjectMonitor * m = omAlloc (Self) ;
  39.           m->Recycle();
  40.           m->_Responsible  = NULL ;
  41.           m->OwnerIsThread = 0 ;
  42.           m->_recursions   = 0 ;
  43.           m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;   // Consider: maintain by type/class
  45.           markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;
  46.           if (cmp != mark) {
  47.              omRelease (Self, m, true) ;
  48.              continue ;       // Interference -- just retry
  49.           }
  50.           markOop dmw = mark->displaced_mark_helper() ;
  51.           assert (dmw->is_neutral(), "invariant") ;
  53.           // Setup monitor fields to proper values -- prepare the monitor
  54.           m->set_header(dmw) ;
  55.           m->set_owner(mark->locker());
  56.           m->set_object(object);
  57.           guarantee (object->mark() == markOopDesc::INFLATING(), "invariant") ;
  58.           object->release_set_mark(markOopDesc::encode(m));
  59.           if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;
  60.           TEVENT(Inflate: overwrite stacklock) ;
  61.           if (TraceMonitorInflation) {
  62.             if (object->is_instance()) {
  63.               ResourceMark rm;
  64.               tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
  65.                 (void *) object, (intptr_t) object->mark(),
  66.                 object->klass()->external_name());
  67.             }
  68.           }
  69.           return m ;
  70.       }
  72.       // CASE: neutral 处于无锁状态
  73.       assert (mark->is_neutral(), "invariant");
  74.       ObjectMonitor * m = omAlloc (Self) ;
  75.       // prepare m for installation - set monitor to initial state
  76.       m->Recycle();
  77.       m->set_header(mark);
  78.       m->set_owner(NULL);
  79.       m->set_object(object);
  80.       m->OwnerIsThread = 1 ;
  81.       m->_recursions   = 0 ;
  82.       m->_Responsible  = NULL ;
  83.       m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;       // consider: keep metastats by type/class
  85.       if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
  86.           m->set_object (NULL) ;
  87.           m->set_owner  (NULL) ;
  88.           m->OwnerIsThread = 0 ;
  89.           m->Recycle() ;
  90.           omRelease (Self, m, true) ;
  91.           m = NULL ;
  92.           continue ;
  93.           // interference - the markword changed - just retry.
  94.           // The state-transitions are one-way, so there's no chance of
  95.           // live-lock -- "Inflated" is an absorbing state.
  96.       }
  98.       if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;
  99.       TEVENT(Inflate: overwrite neutral) ;
  100.       if (TraceMonitorInflation) {
  101.         if (object->is_instance()) {
  102.           ResourceMark rm;
  103.           tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
  104.             (void *) object, (intptr_t) object->mark(),
  105.             object->klass()->external_name());
  106.         }
  107.       }
  108.       return m ;
  109.   }
  110. }