共享模式与基于 Condition 的等待 / 通知机制实现（1）

look_w

共享模式acquire实现流程上文我们讲解了AbstractQueuedSynchronizer独占模式的acquire实现流程，本文趁热打铁继续看一下AbstractQueuedSynchronizer共享模式acquire的实现流程。连续两篇文章的学习，也可以对比独占模式acquire和共享模式acquire的区别，加深对于AbstractQueuedSynchronizer的理解。
先看一下共享模式acquire的实现，方法为acquireShared和acquireSharedInterruptibly，两者差别不大，区别就在于后者有中断处理，以acquireShared为例：

1 2 3 4

public final void acquireShared(int arg) {       if (tryAcquireShared(arg) < 0)             doAcquireShared(arg); }

这里就能看出第一个差别来了：独占模式acquire的时候子类重写的方法tryAcquire返回的是boolean，即是否tryAcquire成功；共享模式acquire的时候，返回的是一个int型变量，判断是否<0。doAcquireShared方法的实现为：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

private void doAcquireShared(int arg) {     final Node node = addWaiter(Node.SHARED);     boolean failed = true;     try {         boolean interrupted = false;         for (;;) {             final Node p = node.predecessor();             if (p == head) {                 int r = tryAcquireShared(arg);                 if (r >= 0) {                     setHeadAndPropagate(node, r);                     p.next = null; // help GC                     if (interrupted)                         selfInterrupt();                     failed = false;                     return;                 }             }             if (shouldParkAfterFailedAcquire(p, node) &&                 parkAndCheckInterrupt())                 interrupted = true;         }     } finally {         if (failed)             cancelAcquire(node);     } }

我们来分析一下这段代码做了什么：

• addWaiter，把所有tryAcquireShared<0的线程实例化出一个Node，构建为一个FIFO队列，这和独占锁是一样的
• 拿当前节点的前驱节点，只有前驱节点是head的节点才能tryAcquireShared，这和独占锁也是一样的
• 前驱节点不是head的，执行”shouldParkAfterFailedAcquire() && parkAndCheckInterrupt()”，for(;;)循环，”shouldParkAfterFailedAcquire()”方法执行2次，当前线程阻塞，这和独占锁也是一样的

确实，共享模式下的acquire和独占模式下的acquire大部分逻辑差不多，最大的差别在于tryAcquireShared成功之后，独占模式的acquire是直接将当前节点设置为head节点即可，共享模式会执行setHeadAndPropagate方法，顾名思义，即在设置head之后多执行了一步propagate操作。setHeadAndPropagate方法源码为：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

private void setHeadAndPropagate(Node node, int propagate) {     Node h = head; // Record old head for check below     setHead(node);     /*      * Try to signal next queued node if:      *   Propagation was indicated by caller,      *     or was recorded (as h.waitStatus) by a previous operation      *     (note: this uses sign-check of waitStatus because      *      PROPAGATE status may transition to SIGNAL.)      * and      *   The next node is waiting in shared mode,      *     or we don't know, because it appears null      *      * The conservatism in both of these checks may cause      * unnecessary wake-ups, but only when there are multiple      * racing acquires/releases, so most need signals now or soon      * anyway.      */     if (propagate > 0 || h == null || h.waitStatus < 0) {         Node s = node.next;         if (s == null || s.isShared())             doReleaseShared();     } }

第3行的代码设置重设head，第2行的代码由于第3行的代码要重设head，因此先定义一个Node型变量h获得原head的地址，这两行代码很简单。