[源码]Condition的原理,简单案例(ArrayBlockingQueue),复杂案例(LinkedBlockingQueue).

* Implements interruptible condition wait.

* <ol>

* <li> If current thread is interrupted, throw InterruptedException

* <li> Save lock state returned by {@link #getState}

* <li> Invoke {@link #release} with

*      saved state as argument, throwing

*      IllegalMonitorStateException  if it fails.

* <li> Block until signalled or interrupted

* <li> Reacquire by invoking specialized version of

*      {@link #acquire} with saved state as argument.

* <li> If interrupted while blocked in step 4, throw exception

* </ol>

*/

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)) { 
           
  //phi注:不在AbstractQueuedSyncronizer的线程阻塞队列里.就park();

condition.signal后,迁移线程到父类的阻塞线程队列,如果父类ReentrantLocker执行release()操作,唤醒队列头线程,但线程还在队列里. 所以不用死循环. 所以说: Lock的孩子的条件队列和Lock自己的阻塞队列是互斥的.

LockSupport.park(this);

if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)

break;

}

if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
// 如果是第一个,那么就获取锁,从队列中剔除并执行,如果不是就重新park()

interruptMode = REINTERRUPT;

if (node.nextWaiter != null)

unlinkCancelledWaiters();

if (interruptMode != 0)

reportInterruptAfterWait(interruptMode);

}

* Removes and transfers nodes until hit non-cancelled one or

* null. Split out from signal in part to encourage compilers

* to inline the case of no waiters.

* @param first (non-null) the first node on condition queue

*/

private void doSignal(Node first) {

do {

if ( (firstWaiter = first.nextWaiter) == null)
 //这一步做的操作重新设置队列头.

lastWaiter = null;

first.nextWaiter = null;                       //隔断老的队列头和原队列的连接.

} while (!transferForSignal(first) && 
           //transferForSignal把线程从条件队列中转移到阻塞队列中.但没有unpark操作

(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).

*/

Node p = enq(node);

int ws = p.waitStatus;

if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))

LockSupport.unpark(node.thread);  
          //正常情况不会进到这里. 那么何时进行unpark呢? unpark是上一个线程释放锁时进行的操作. unpark阻塞队列列头的线程.

return true;

}