95后百万年薪架构师分享：两道BT的多线程经典面试题 （一） | 干货分享

JVM_ENTRY(void， JVM_MonitorNotify(JNIEnv* env， jobject handle))
    Handle obj(THREAD， JNIHandles：：resolve_non_null(handle));
// 直接调用ObjectSynchronizer：：notify
ObjectSynchronizer：：notify(obj， CHECK); 
JVM_END

void ObjectSynchronizer：：notify(Handle obj， TRAPS) {
    if (UseBiasedLocking) { 
        // 如果使用偏向锁，那么取消偏向锁
        BiasedLocking：：revoke_and_rebias(obj， false， THREAD);
    }
    markOop mark = obj->mark();
    if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) { 
        // 如果是轻量级锁，那么直接返回，因为wait操作需要通过对象监视器来做
        return;
    }
    ObjectSynchronizer：：inflate(THREAD， obj())->notify(THREAD);
}

void ObjectMonitor：：notify(TRAPS) {
    CHECK_OWNER();
    if (_WaitSet == NULL) { 
        // 如果等待集为空，直接返回
        return ;
    }
    int Policy = Knob_MoveNotifyee ;        // 移动策略，这里默认是2
    Thread：：SpinAcquire (&_WaitSetLock， "WaitSet - notify") ;   // 首先对等待集上自旋锁
    // 调用DequeueWaiter将一个等待线程从等待集中拿出来
    ObjectWaiter * iterator = DequeueWaiter() ; 
    if (iterator != NULL) {
        if (Policy != 4) {      // 如果策略不等于4那么将线程的状态修改为TS_ENTER
            iterator->TState = ObjectWaiter：：TS_ENTER ;
        }
        iterator->_notified = 1 ;   // 唤醒计数器
        Thread * Self = THREAD;
        iterator->_notifier_tid = Self->osthread()->thread_id();
        ObjectWaiter * List = _EntryList ;
        if (Policy == 0) {          // 如果策略为0，那么头插入到entrylist中
            if (List == NULL) {     // 如果entrylist为空，那么将当前监视器直接作为_EntryList 头结点
                iterator->_next = iterator->_prev = NULL ;
                _EntryList = iterator ;
            } else {            // 否则头插
                List->_prev = iterator ;
                iterator->_next = List ;
                iterator->_prev = NULL ;
                _EntryList = iterator ;
            }
        } else if (Policy == 1) {   // 如果策略为1，那么插入entrylist的尾部
            if (List == NULL) {
                iterator->_next = iterator->_prev = NULL ;
                _EntryList = iterator ;
            } else {
                ObjectWaiter * Tail ;
                for (Tail = List ; Tail->_next != NULL ; Tail = Tail->_next) ;
                Tail->_next = iterator ;
                iterator->_prev = Tail ;
                iterator->_next = NULL ;
            }
        } else if (Policy == 2) {
            // 如果策略为2，那么如果entrylist为空，那么插入entrylist，否则插入cxq队列
            if (List == NULL) {
                iterator->_next = iterator->_prev = NULL ;
                _EntryList = iterator ;
            } else {
                iterator->TState = ObjectWaiter：：TS_CXQ ;
                for (;;) {
                    ObjectWaiter * Front = _cxq ;
                    iterator->_next = Front ;
                    if (Atomic：：cmpxchg_ptr (iterator， &_cxq， Front) == Front) {
                        break ;
                    }
                }
            }
        } else
            if (Policy == 3) {      // 如果策略为3，那么直接插入cxq
                iterator->TState = ObjectWaiter：：TS_CXQ ;
                for (;;) {
                    ObjectWaiter * Tail ;
                    Tail = _cxq ;
                    if (Tail == NULL) {
                        iterator->_next = NULL ;
                        if (Atomic：：cmpxchg_ptr (iterator， &_cxq， NULL) == NULL) {
                            break ;
                        }
                    } else {
                        while (Tail->_next != NULL) Tail = Tail->_next ;
                        Tail->_next = iterator ;
                        iterator->_prev = Tail ;
                        iterator->_next = NULL ;
                        break ;
                    }
                }
            } else { 
                // 否则直接唤醒线程，让线程自己去调用enterI进入监视器
                ParkEvent * ev = iterator->_event ;
                iterator->TState = ObjectWaiter：：TS_RUN ;
                OrderAccess：：fence() ;
                ev->unpark() ;
            }
    }
    Thread：：SpinRelease (&_WaitSetLock) ; // 释放等待集自旋锁
}

inline ObjectWaiter* ObjectMonitor：：DequeueWaiter() {
    ObjectWaiter* waiter = _WaitSet;        // 很简单对吧，直接从头部拿
    if (waiter) {                       // 如果waiter不为空，那么从等待集中断链
        DequeueSpecificWaiter(waiter);
    }
    return waiter;
}
inline void ObjectMonitor：：DequeueSpecificWaiter(ObjectWaiter* node) {
    ObjectWaiter* next = node->_next;
    if (next == node) {                 // 如果只有一个节点，那么直接将等待集清空即可
        _WaitSet = NULL;
    } else {                            // 否则双向链表的断链基础操作
        ObjectWaiter* prev = node->_prev;
        next->_prev = prev;
        prev->_next = next;
        if (_WaitSet == node) {
            _WaitSet = next;
        }
    }
    // 断开连接后，也需要把断下来的节点，next和prev指针清空
    node->_next = NULL;
    node->_prev = NULL;
}