【Java 并发】【九】【AQS】【三】基于AQS的共享锁实现、底层源码深度剖析

public final void acquireShared(int arg) {
    // 1. tryAcquireShared < 0 表示获取共享锁失败
    if (tryAcquireShared(arg) < 0)
        // 2. 然后进入doAcquireShared方法
        doAcquireShared(arg);
}

private void doAcquireShared(int arg) {
    // 将当先线程封装成一个Node节点，节点模式为共享锁模式SHARED
    // 这里的addWaiter方法的源码，上一节将互斥锁的时候讲过了，一模一样的
    final Node node = addWaiter(Node.SHARED);
    // 获取锁成功还是失败的标识
    boolean failed = true;
    try {
        // 是否被中断标识
        boolean interrupted = false;
        for (;;) {
            // 获取节点node的前一个节点p
            final Node p = node.predecessor();
            // 如果p是head，则node自己则是第二节点
            // 上一节我们就说过了哈，AQS规定第二节点是可以去争抢锁的
            if (p == head) {
                // 这里调用子类的tryAcquireShared方法去尝试获取锁
                // r >= 0 表示获取锁成功，r < 0 表示获取锁失败
                int r = tryAcquireShared(arg);
                // 如果 r >= 0，获取锁成功
                if (r >= 0) {
                    // 这个时候可能锁还有剩余，需要在传播下去
                    // 就是把等待队列中的节点，让他们也去获取锁
                    // 嘿，兄弟，起来了，还有锁资源，赶紧去争抢把 这里就看出和互斥锁不一样了，互斥锁只有setHead没有传播，共享锁是需要传播的
                    setHeadAndPropagate(node, r);
                    // 将头节点的next设置为null,也就是移除头节点了
                    p.next = null; // help GC
                    // 如果interrupted为true，表示线程被中断了
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            // 走到这里，说明上面争抢锁失败了，判断是不是要挂起，源码上一节剖析过了
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 这里的parkAndCheckInterrupted是将线程挂起，源码上一节剖析过了
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        // 这里是获取锁失败，将自己插入等待队列的节点删除
        // 源码在上一节剖析过了
        if (failed)
            cancelAcquire(node);
    }
}

private void setHeadAndPropagate(Node node, int propagate) {
    // 获取头节点
    Node h = head;
    // 这里就是将自己设置成head节点
    // 所以后面资源传播的过程，只要资源还充足，head节点是不断变化的
    // 因为这里只要线程获取了资源成功，就把自己设置成头节点
    setHead(node);
    // propagate就是上面我们调用r = tryAcquireShared的返回值
    // 也就是剩余资源的个数，如果propagate > 0 说明资源还剩余，继续传播
    // head == null这里说的是head节点是空，说明头节点已经获取资源完毕
    // 可能head应该释放资源了，所以可能这个时候需要去唤醒别的线程
    // h.waitSatatus < 0 说明head节点后面有线程在等待你唤醒，
    // head节点表示当前已经获取了资源的线程，这个时候你需要把后面的节点唤醒
    // 让head后面节点的去竞争资源
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        // 如果下一个节点是共享锁模式，就唤醒继续传播
        if (s == null || s.isShared())
            // 这里的doReleaseShared方法其实就是唤醒和传播的具体逻辑了
            doReleaseShared();
    }
}

private void doReleaseShared() {
    for (;;) {
        // 获取头节点
        Node h = head;
        // head != null && head != null说明等待队列还有其他的节点
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            // 如果是SINGAL(-1)，说明需要唤醒自己的下一个节点
            // 这里我们上一节讲过了SINGAL就是一个信号，
            // 这个信号表示你需要唤醒你的下一个节点
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue; // loop to recheck cases
                // 这里就是唤醒h的下一个节点了，源码我们上一节分析过了
                unparkSuccessor(h);
            }
            // 设置已经在传播资源了
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue; // loop on failed CAS
        }
        
        // 资源在传播的过程中，如果有新的节点获取到线程，会把自己设置成head
        // 则只要资源还有足够的剩余，说明head是不断变化的
        // 如果h == head说明头节点不再变化，也就还没有新的节点获取资源了
        // 这个时候就传播结束了，退出循环
        if (h == head) // loop if head changed
            break;
    }
}

public final boolean releaseShared(int arg) {
    // 1. 调用子类的tryReleaseShared方法，实际去释放资源
    if (tryReleaseShared(arg)) {
        // 2. 释放资源之后竟然是调用这个，我们上面刚刚讲过
        // 3. 这里其实本质上就是传播资源，继续唤醒后面的节点来竞争资源
        // 这里刚刚讲解过，理解起来应该是简单了
        doReleaseShared();
        return true;
    }
    return false;
}