JAVA基础：Condition原理解析

Condition用途

我们知道当多个线程需要访问一个共享资源时，需要第共享资源加锁。 当一个线程释放锁时，所有等待锁的线程都会尝试去获取锁。 但是如果我们想只让部分等待锁的线程去获取锁时，就需要用到Condition。

Condition原理介绍

Condition具体实现在AbstractQueuedSynchronizer类中。这个类中管理了一个阻塞队列和N多个条件队列。阻塞队列记录了等待获取锁的线程，头结点记录了当前正在运行的线程。条件队列记录了由Condition.await()阻塞的线程，一个Lock可以有多个Condition,每个Condition是一个队列。Condition是AbstractQueuedSynchronizer的一个内部类ConditionObject,所以创建的Condition对象中是可以访问整个AbstractQueuedSynchronizer对象的属性的，通过这样将Condition与Lock相关联。

await()阻塞线程

await()方法释放锁，并将当前线程封装成一个node加入到条件队列的尾部。同时阻塞当前线程，等待唤醒。在调用await()方法时，当前线程必须是获取到了锁的状态，否则会抛出异常IllegalMonitorStateException。

signal()唤醒线程

signal()将条件队列中的第一个节点加入到阻塞队列的尾端，表示可以被唤醒执行
（图片来源：https://blog.csdn.net/fuyuwei2015/article/details/72602182）

Condition源码分析

await()释放锁阻塞线程

前面说到的是会将线程加入到条件队列中，通过方法addConditionWaiter。每当线程从LockSupport.park中退出继续运行时，然后通过isOnSysnQueue方法来判断是否可以退出阻塞。isOnSyncQueue表示线程是否在阻塞队列中，如果在则退出。或者checkInterruptWhileWaiting判断线程被打断后会退出循环。

public final void await() throws InterruptedException {
           if (Thread.interrupted())
               throw new InterruptedException();
           //加入条件队列
           Node node = addConditionWaiter();
           // 释放锁
           int savedState = fullyRelease(node);
           int interruptMode = 0;
           // 
           while (!isOnSyncQueue(node)) {
               LockSupport.park(this);
               if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                   break;
           }
           if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
               interruptMode = REINTERRUPT;
           if (node.nextWaiter != null) // clean up if cancelled
               unlinkCancelledWaiters();
           if (interruptMode != 0)
               reportInterruptAfterWait(interruptMode);
       }

signal()通知await()线程继续运行

其实正常情况下，signal()并不会执行LockSupport.unpark来唤醒等待的线程，而是将线程节点从条件队列移动到了阻塞队列。那么当运行signal()的线程释放了锁以后，那么调用await()的线程LockSupport.park阻塞的，就可以被唤醒。

public final void signal() {
//当前线程是否获取独占锁，isHeldExclusively由子类实现
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
        if (first != null)
        	//通知
            doSignal(first);
}
private void doSignal(Node first) {
    do {
    		//断掉节点与条件队列的联系
          if ( (firstWaiter = first.nextWaiter) == null)
              lastWaiter = null;
          first.nextWaiter = null;
      } while (!transferForSignal(first) &&
               (first = firstWaiter) != null);
  }

/**
  * Transfers a node from a condition queue onto sync queue.
  * Returns true if successful.
  * @param node the node
  * @return true if successfully transferred (else the node was
  * cancelled before signal)
  */
 final boolean transferForSignal(Node node) {
     /*
      * If cannot change waitStatus, the node has been cancelled.
      */
     if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
         return false;

     /*
      * Splice onto queue and try to set waitStatus of predecessor to
      * indicate that thread is (probably) waiting. If cancelled or
      * attempt to set waitStatus fails, wake up to resync (in which
      * case the waitStatus can be transiently and harmlessly wrong).
      */
      // enq(node): 自旋进入阻塞队列的队尾
     // 注意，这里的返回值 p 是 node 在阻塞队列的前驱节点
     Node p = enq(node);
     int ws = p.waitStatus;
     // 通常这里的ws是小于0的，compareAndSetWaitStatus是会返回true的，假设发生了阻塞队   列中的前驱节点取消等待ws>0，或者 CAS 失败，只要唤醒线程，会重新阻塞。
     if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
         LockSupport.unpark(node.thread);
     return true;
 }