wait/notify原理 - 图1

    • Owner线程发现条件不满足,调用wait方法,即可进入WaitSet编程WAITING状态;
    • BLOCKED和WAITING的线程都处于阻塞状态,不占用CPU时间片;
    • BLOCKED线程会在Owner线程释放锁时唤醒;
    • WAITING线程会在Owner线程调用notify或notifyAll时唤醒,但唤醒后并不意味着立刻获得锁,仍需进入EntryList重新竞争;


    C++原理

    1. void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
    2.        // 创建线程
    3.        Thread * const Self = THREAD ;
    4.     // ...
    5.        // 将线程放进node双向链表中
    6.        ObjectWaiter node(Self);
    7.        // 等待队列状态
    8.        node.TState = ObjectWaiter::TS_WAIT ;
    9.        Self->_ParkEvent->reset() ;
    10.        // 中断标记
    11.        OrderAccess::fence(); 
    13.      // ...
    14.        // 加入队列
    15.        AddWaiter (&node) ;
    16.        // 下面就是一些运行后方法，改变node的状态
    17.        intptr_t save = _recursions; // record the old recursion count
    18.        _waiters++;                  // 等待队列加值
    19.        _recursions = 0;             // 设置重入锁
    20.        exit (true, Self) ;                    // 退出monitor
    21.        guarantee (_owner != Self, "invariant") ;
    23.      // 线程状态
    24.      ObjectWaiter::TStates v = node.TState ;
    25.      // 线程状态为运行态
    26.      if (v == ObjectWaiter::TS_RUN) {
    27.          enter (Self) ;
    28.      } else {
    29.          guarantee (v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant") ;
    30.          ReenterI (Self, &node) ;
    31.          node.wait_reenter_end(this);
    32.      }
    33. }
    35. inline void ObjectMonitor::AddWaiter(ObjectWaiter* node) {
    36.   assert(node != NULL, "should not dequeue NULL node");
    37.   assert(node->_prev == NULL, "node already in list");
    38.   assert(node->_next == NULL, "node already in list");
    39.   // 将节点放在队列末尾（循环双向链表）
    40.   if (_WaitSet == NULL) {
    41.     _WaitSet = node;
    42.     node->_prev = node;
    43.     node->_next = node;
    44.   } else {
    45.     ObjectWaiter* head = _WaitSet ;
    46.     ObjectWaiter* tail = head->_prev;
    47.     assert(tail->_next == head, "invariant check");
    48.     tail->_next = node;
    49.     head->_prev = node;
    50.     node->_next = head;
    51.     node->_prev = tail;
    52.   }
    53. }
    55. //线程释放调用exit方法
    56. void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) {
    57.     // 创建线程
    58.     Thread * Self = THREAD ;
    59.     // 线程不是所属者
    60.    if (THREAD != _owner) {
    61.        // 执行检查锁拥有者
    62.        if (THREAD->is_lock_owned((address) _owner)) {
    63.            // 将该线程设置给拥有者
    64.            _owner = THREAD ;
    65.            // 设置重入锁
    66.            _recursions = 0 ;
    67.            // 拥有者标记
    68.            OwnerIsThread = 1 ;
    69.        } else {
    70.            // 抛出异常
    71.            ...
    72.        }
    74.    //_recursions计数不等于0；说明还没出代码块；进入减减操作，
    75.    if (_recursions != 0) {
    76.      _recursions--;        // this is simple recursive enter
    77.      TEVENT (Inflated exit - recursive) ;
    78.      return ;
    79.    }
    80.    if ((SyncFlags & 4) == 0) {
    81.       _Responsible = NULL ;
    82.    }
    83.     ...
    84.         // 计数为0；开始唤醒cq竞争队列、enteryList阻塞队列
    85.       ObjectWaiter * w = NULL ;//w就是被唤醒的线程
    87.        // qmode = 2：直接绕过EntryList阻塞队列，从cxq（竞争）队列中获取线程用于竞争锁
    88.       if (QMode == 2 && _cxq != NULL) {
    90.           w = _cxq ;
    91.           ExitEpilog (Self, w) ;
    92.           return ;
    93.       }
    94.         // qmode =3：从cxq（竞争）队列插入EntryList（阻塞）尾部；
    95.          if (QMode == 3 && _cxq != NULL) {
    96.              ...
    97.          }
    98.        // qmode =4：从cxq队列插入到_EntryList头部
    99.       if (QMode == 4 && _cxq != NULL) {
    100.           ...
    101.       }
    102. }
    104. //唤醒线程
    105. void ObjectMonitor::ExitEpilog (Thread * Self, ObjectWaiter * Wakee) {
    106.     ParkEvent * Trigger = Wakee->_event ;
    107.     // 唤醒之前被park()挂起的线程.
    108.    Trigger->unpark() ;// invoke ObjectMonitor::EnterI 方法，继续竞争
    109.    if (ObjectMonitor::_sync_Parks != NULL) {
    110.       ObjectMonitor::_sync_Parks->inc() ;
    111.    }
    112. }
    115. // 如果锁是空(cxq == null && succ == null)
    116. // 并且在系统中并不是立即把线程从WaitSet移到EntryList
    117. // 我们只是会唤醒一些线程，通过unpark()做到
    118. void ObjectMonitor::notify(TRAPS) {
    119.       // 任务调度器
    120.       int Policy = Knob_MoveNotifyee ;
    121. }