AbstractQueuedSynchronizer 之 共享锁

AbstractQueuedSynchronizer 之 共享锁

acquireShared

/**
 * Acquires in shared mode, ignoring interrupts.  Implemented by
 * first invoking at least once {@link #tryAcquireShared},
 * returning on success.  Otherwise the thread is queued, possibly
 * repeatedly blocking and unblocking, invoking {@link
 * #tryAcquireShared} until success.
 *
 * 获取共享锁，忽略中断。执行时先调用 truAcquireShared 尝试获取锁，
 * 如果获取成功就返回，否则当前线程入队，可能会被重复阻塞、唤醒
 */
public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

tryAcquireShared

/**
 * 同 tryAcquire 一样，需要子类去实现
 */
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}

doReleaseShared

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

releaseShared

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) { // 先尝试释放锁，如果释放成功再唤醒等待的线程
        doReleaseShared();
        return true;
    }
    return false; // 释放失败返回 false
}

tryReleaseShared

/**
 * 同 tryRelease 一样，需要子类去实现
 */
protected boolean tryReleaseShared(int arg) {
    throw new UnsupportedOperationException();
}

doReleaseShared

private void doReleaseShared() {
    for (;;) { // 死循环，直到所有的唤醒所有的等待线程才结束
        Node h = head;
        // 如果有线程在等待
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) { // 如果头结点状态为 SIGNAL，就唤醒继任结点
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) // 唤醒失败就循环唤醒
                    continue;            // loop to recheck cases
                unparkSuccessor(h); // 唤醒成功后解除阻塞
            }
            // 如果是 0，那么所有的锁都已经释放了，将 h 的状态设置为 PROPAGATE，表示传播唤醒
            // 队列中阻塞的线程在
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        // 如果头结点没有变，也就是 h == null 或者 h == tail 成立，那么退出
        if (h == head)                   // loop if head changed
            break;
    }
}