[Java] Java并发编程之Condition源码分析（推荐）

• （1）await()方法可以阻塞当前线程，并释放锁。
  
• （2）在获取锁后可以调用signal()通知被await()阻塞的线程"激活"。
  

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);
  }

• （1）先判断是否当前线程是否被中断中断则抛出中断异常如果未中断调用addconditionwaiter()加入等待队列
  
• （2）调用fullyrelease(node)释放锁使同步阻塞队列的下个节点线程能获取锁。
  
• （3）调用isonsyncqueue(node)判断是否在同步阻塞队列，这里的加入同步阻塞队列操作是在另一个线程调用signal()后加入，如果不在同步阻塞队列会进行阻塞直到被激活。
  
• （4）如果被激活然后调用checkinterruptwhilewaiting(node)判断是否被中断并获取中断模式。
  
• （5）继续调用isonsyncqueue(node)判断是否在同步阻塞队列。
  
• （6）是则调用acquirequeued(node, savedstate) 获取锁，这里如果获取不到也会被阻塞，获取不到原因是在第一次调用isonsyncqueue(node)前，可能另一个线程已经调用signal()后加入到同步阻塞队列，然后调用acquirequeued(node, savedstate) 获取不到锁并阻塞。acquirequeued(node, savedstate)也会返回当前线程是否被中断，如果被中断设置中断模式。
  
• （7）在激活后调用unlinkcancelledwaiters()清理等待队列的已经被激活的节点。
  
• （8）最后判断当前线程是否被中断，如果被中断则对中断线程做处理。
  

private node addconditionwaiter() {
    //获取等待队列尾部节点
    node t = lastwaiter;
    //如果尾部状态不为condition，如果已经被"激活"，清理之，然后重新获取尾部节点
    if (t != null && t.waitstatus != node.condition) {
    unlinkcancelledwaiters();
    t = lastwaiter;
    }
    //创建以当前线程为基础的节点，并将节点模式设置成condition
    node node = new node(thread.currentthread(), node.condition);
    //如果尾节点不存在，说明队列为空，将头节点设置成当前节点
    if (t == null)
    firstwaiter = node;
    //如果尾节点存在，将此节点设置成尾节点的下个节点
    else
    t.nextwaiter = node;
    //将尾节点设置成当前节点
    lastwaiter = node;
    return node;
  }

final int fullyrelease(node node) {
  boolean failed = true;
  try {
    //获取阻塞队列中当前线程节点的锁状态值
    int savedstate = getstate();
    //释放当前线程节点锁
    if (release(savedstate)) {
    failed = false;
    return savedstate;
    } else {
    throw new illegalmonitorstateexception();
    }
  } finally {
    //释放失败讲节点等待状态设置成关闭
    if (failed)
    node.waitstatus = node.cancelled;
  }
  }

final boolean isonsyncqueue(node node) {
    //判断当前节点是否是condition或者前置节点是否为空如果为空直接返回false
  if (node.waitstatus == node.condition || node.prev == null)
    return false;
    //如果下个节点存在，则在同步阻塞队列中返回true
  if (node.next != null) // if has successor, it must be on queue
    return true;
    //遍历查找当前节点是否在同步阻塞队列中
  return findnodefromtail(node);
  }
  private boolean findnodefromtail(node node) {
  node t = tail;
  for (;;) {
    if (t == node)
    return true;
    if (t == null)
    return false;
    t = t.prev;
  }
  }

• （1）第一步先判断次节点是否condition状态或者前置节点是否存在，如果是表明不在队列中返回false，阻塞队列中的状态一般是0或者signal状态而且如果当前如果当前节点在队列阻塞中且未被激活前置节点一定不为空。
  
• （2）第二步判断节点的下个节点是否存在，如果存在则表明当前当前节点已加入到阻塞队列中。
  
• （3）如果以上2点都没法判断，也有可能刚刚加入到同步阻塞队列中，所以调用findnodefromtail(node node)做最后的遍历查找。查找从队列尾部开始查，从尾部开始查的原因是可能刚刚加入到同步阻塞队列中，从尾部能快速定位。
  

private int checkinterruptwhilewaiting(node node) {
    return thread.interrupted() ?
    (transferaftercancelledwait(node) ? throw_ie : reinterrupt) :
    0;
  }
 
final boolean transferaftercancelledwait(node node) {
  if (compareandsetwaitstatus(node, node.condition, 0)) {
    enq(node);
    return true;
  }
  while (!isonsyncqueue(node))
    thread.yield();
  return false;
  }

• （1）用cas方式将节点状态改错等待状态改成condition，并加入到同步阻塞队列中返回true
  
• （2）如果不能加入到同步阻塞队列就自旋一直等待加入
  

private void unlinkcancelledwaiters() {
    //获取等待队列头节点
    node t = firstwaiter;
    node trail = null;
    while (t != null) {
    //获取下个节点
    node next = t.nextwaiter;
    //如果状态不为condition说明已经加入阻塞队列需要清理掉
    if (t.waitstatus != node.condition) {
      t.nextwaiter = null;
      if (trail == null)
      firstwaiter = next;
      else
      //获取下个节点
      trail.nextwaiter = next;
      if (next == null)
      lastwaiter = trail;
    }
    else
      trail = t;
    t = next;
    }
  }

private void reportinterruptafterwait(int interruptmode)
    throws interruptedexception {
    //如果是throw_ie模式直接抛出异常
    if (interruptmode == throw_ie)
    throw new interruptedexception();
    //如果是reinterrupt模式标记线程中断由上层处理中断
    else if (interruptmode == reinterrupt)
    selfinterrupt();
  }

public final void signal() {
    //是否当前线程持有锁
    if (!isheldexclusively())
    throw new illegalmonitorstateexception();
    node first = firstwaiter;
    //通知"激活"头节点线程
    if (first != null)
    dosignal(first);
  }

protected final boolean isheldexclusively() {
   return getexclusiveownerthread() == thread.currentthread();
   }

private void dosignal(node first) {
    do {
    //头指头后移一位，如果后面的节点为空，则将尾指头也指向空，说明队列为空了
    if ( (firstwaiter = first.nextwaiter) == null)
      lastwaiter = null;
    //清空头节点的下个节点
    first.nextwaiter = null;
    //如果"激活"失败者取下个继续，直到成功或者遍历完
    } while (!transferforsignal(first) &&
       (first = firstwaiter) != null);
  }

final boolean transferforsignal(node node) {
    //将condition状态设置成0
  if (!compareandsetwaitstatus(node, node.condition, 0))
    return false;
    //加入到同步阻塞队列
  node p = enq(node);
  int ws = p.waitstatus;
    //状态异常直接激活
  if (ws > 0 || !compareandsetwaitstatus(p, ws, node.signal))
    locksupport.unpark(node.thread);
  return true;
  }