1.3 详解AQS-acquireShared方法

acquireShared是共享模式下获取锁的方法。和acquire方法相似，都是先获取锁，如果获取不到则添加到队列中，从队列中自旋获取锁。自旋获取锁代码：

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

不同的地方在于，如果当前节点获取了锁，根据获取锁的返回值：大于0、或者等于0，有不同的处理方式。先说规则：

• 等于0，仅当前线程持有锁，说明没有其他共享锁可以获取了
• 大于0，唤醒后继的共享节点。说明还有剩余的共享锁

具体实现在setHeadAndPropagate方法中：

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    setHead(node);

    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

主要看后面的条件判断语句。其实分为三个条件：

1. propagate >0 此时说明有剩余的共享锁
2. old head 的waitStatus < 0 说明旧的头结点非初始化节点，且没有被取消
3. new head 的waiteStatus <0 说明当前头节点没有被取消

满足这三个任意一个条件时，那么唤醒后续的节点。在唤醒后续节点时，要判断是否有后续节点以及后续节点是否为共享模式。

条件1不做过多解释。看条件2和3，对于条件2和3来讲，不可能存在节点为null的情况，因为只要有节点入队，无论新旧头结点都是存在的。当执行到(h = head) == null时，旧的头结点有可能被GC回收，但是此时已经用不到它了，回收与否无关紧要。重点在新旧节点的状态。

当条件1失败时，说明此时没有剩余的共享锁了，但是如果新旧头结点的状态支持获取锁(小于0)，仍然会唤醒后继节点。什么时候新旧头结点的状态不支持呢？

• 头结点被取消 cancle状态，大于0。cancle状态时，说明获取流程有异常，此时不支持获取锁。
• 头结点已经被释放(unparkSuccessor) 初始化状态，等于0。初始化状态或者获取锁后，从SIGNAL转换到0。即此时刚获取锁

如果条件1失败，条件2成立，同步状态为：没有多余的锁，且旧的头结点还持有锁。此时依然来唤醒后继节点。这个时候，既然没有资源，那么唤醒后的线程依然会处于自旋的状态来获取锁，如果获取不到，会继续阻塞。那么此时为什么要唤醒后继线程呢？

先看头结点状态什么时候小于0？
都是在doReleaseShared方法调用compareAndSetWaitStatus(h, 0, Node.PROPAGATE)的时候，此时说明旧的头结点处于释放的过程中。那么此时来唤醒后继线程有一定概率可以获取锁

如果条件1和2都失败，3成立了。就是说旧的头结点状态不支持获取锁，而新的头结点状态支持获取锁。但是支持获取锁并不意味着一定能获取。此时仍然会有不必要的唤醒。

释放操作，doReleaseShared：

private void doReleaseShared() {

    for (;;) {
        Node h = head;
        //队列内有节点
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            
            if (ws == Node.SIGNAL) {
               //如果没有设置状态成功，那么下一次循环处理
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                //如果成功了，唤醒后继节点。之后会继续检查
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                //失败了说明有其他节点进来，status变为了SIGNAL
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

大致理解一下：
当队列有节点时，循环唤醒后继节点。当队列中没有节点时，退出循环。循环要做事情：

• 把头结点状态设置为0 && 唤醒后继节点。唤醒操作LockSupport.unpark
• 然后将头结点的状态置为PROPAGATE

队列内有节点时，那么根据后继节点的状态分为两种情况：

1. 竞争比较激烈，锁不够，需要头结点去唤醒后继节点。此时头结点的状态为SIGNAL
2. 竞争不激烈，锁足够，不需要头结点唤醒后继节点。此时头结点的状态为0

第一种情况下，需要将头结点的状态设置为0，然后唤醒后继线程。设置为0说明没有多余的锁以供后继节点竞争。这里如果失败了，会进入下一个循环。如果失败了说明此时头结点的状态该不在是SIGNAL,即有其他线程调用了releaseShared方法，此时后继线程由其他线程唤醒。其他线程退出了循环，当前线程进入下一次循环。

当前线程第二次进入循环时，此时状态应该是0，说明不需要唤醒后继节点了。那么将当前线程的状态设置为PROPAGATE,然后退出循环。如果此时设置失败，进入下一个循环。那么为什么会失败？

头结点的状态为0还有一个时刻，就是初始化的时候。如果当前头结点持有最后一个共享锁，且在释放的过程中，此时有新节点加入，且因为无法获取锁，将前置节点的状态设置为SIGNAL,然后新节点阻塞。那么在头结点释放的时候，状态从0变为了SIGNAL,此时CAS失败。如果失败了，下一个循环头结点的其实状态为SIGNAL

注意：

1. 在释放过程中不会存在setHead这样的操作，头结点的改变只有在进队和获取到锁的时候。对于共享模式来说，头结点的含义是最后一个获取共享锁的节点。
2. 释放操作只是改变了当前头结点的状态，并没有做其他操作。改变为0，说明锁不够用了，后续节点需要竞争；改变为PROPAGATE说明锁够用，后续节点可以获取锁。