队列同步器AQS的实现与分析——共享锁模式

AQS获取共享锁是通过调用acquireShared() 这个顶层方法

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

这个方法中有一个 if 判断，当tryAcquireShared()这个返回值是小于0的时候获取锁失败，进入doAcquireShared()方法。tryAcquireShared()方法是用来获取共享模式下的锁，对于tryAcquireShared()这个方法我们重点看一下他的返回值。
当失败的时候返回的是负值，如果返回的是0表示获取共享模式成功但是它下一个节点的共享模式无法获取成功。如果返回的是大于0，表示当前线程获取共享模式成功，并且它后面的线程也可以获取共享模式。

当共享模式获取失败的时候，我们看一下doAcquireShared()源代码做了哪些操作。

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()方法在上一篇文章中已经按照源码详细的讲解过，它主要是封装为Node节点，并且把该节点添加到队列的尾部。此处传入共享模式的参数，节点就变成了共享模式。

在doAcquireShared(int arg)方法自旋过程中，如果当前节点的前驱节点为头节点时，尝试获取同步状态，如果返回值大于等于0，表示该次获取同步状态成功，调用setHeadAndPropagate()方法设置当前节点为头节点，并从自旋过程中退出。（如果在获取锁自旋的过程中中断过，那么那么将当前线程中断）

如果当前节点的前驱节点不是头节点，则进入shouldParkAfterFailedAcquire()判断，该方法在独占模式这篇文章里都有详细的解释。

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

此方法传递了两个参数，一个是当前节点，一个是tryAcquireShared方法的返回值。从源代码中我门看到它首先记录了当前头节点，然后它通过setHead()方法把当前获取到锁的节点设置为头节点。通过 if 语句把符合条件的继续唤醒后继节点，如果下一个节点为空那么调用doReleaseShared方法，doReleaseShared方法继续唤醒后面的节点。

我们来看一下releaseShared的源代码，此方法是共享模式释放资源的顶层方法。

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

tryReleaseShared方法获取共享模式资源释放，如果释放成功那么会调用doReleaseShared继续唤醒下一个节点。

我们继续看一下具体的唤醒操作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))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

通过源代码我们发现，当前线程状态如果是Node.SIGNAL，Node.SIGNAL的值是-1，是一个静态常量，此值表示当前线程被挂起。如果当前线程被挂起，那么更新当前线程的状态值为0。如果更新失败那么就继续。更新成功后调用unparkSuccessor()此方法是唤醒共享锁的第一个节点。如果本身头节点属于重置状态waitStatus==0，并且把它设置为传播状态那么就向下一个节点传播。

我们在看一下unparkSuccessor这个方法的源码

private void unparkSuccessor(Node node) {    
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

该方法在独占模式这篇文章里也有详细的解释。