AQS 等待队列中的线程自旋多少次后挂起？

以 ReentrantLock#lock() 的非公平锁实现为例

结论：节点在加入等待队列后会进行两次自旋，获取不到锁后线程挂起，等待前驱节点唤醒。

此外，AQS 在节点加入队列前也会多次尝试获取资源，通过以上方式，在高并发场景中很好的平衡了 长时间自旋的开销 和 线程阻塞的性能损耗（频繁的上下文切换）。

核心代码：

// AbstractQueuedSynchronizer
// 线程直接获取资源失败，加入等待队列，通过自旋 + 阻塞获取锁
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 自旋操作，for 循环中并没有明确的自旋次数，答案藏在 shouldParkAfterFailedAcquire() 中
        for (;;) {
            final Node p = node.predecessor();
            // 检查是否能获取资源
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 检查是否需要阻塞
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

// AbstractQueuedSynchronizer
// 检查线程是否需要阻塞
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // SIGNAL 状态表明应该阻塞
    if (ws == Node.SIGNAL)
        return true;
    // 对应的节点状态是 CANCELLED，直接跳过
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 剩余的情况都会将前驱节点的状态置为 SIGNAL
        // 这样在下一次自旋时就会返回 true，进入阻塞，也就是自旋两次的由来
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

完整加锁链路：

// ReentrantLock
public void lock() {
    sync.lock();
}

// ReentrantLock#Sync
abstract void lock();

// ReentrantLock#NonfairSync
final void lock() {
    // 资源空闲时直接获取
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 资源被占用时
        acquire(1);
}

// AbstractQueuedSynchronizer
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

// ReentrantLock#NonfairSync
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

// ReentrantLock#Sync
// 该方法做了两件事情：资源空闲时获取资源、当前线程重入获取资源（ReentrantLock 是可重入锁）
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

// AbstractQueuedSynchronizer
// 线程直接获取资源失败，加入等待队列，通过自旋 + 阻塞获取锁
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 自旋操作，for 循环中并没有明确的自旋次数，答案藏在 shouldParkAfterFailedAcquire() 中
        for (;;) {
            final Node p = node.predecessor();
            // 检查是否能获取资源
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 检查是否需要阻塞
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

// AbstractQueuedSynchronizer
// 检查线程是否需要阻塞
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // SIGNAL 状态表明应该阻塞
    if (ws == Node.SIGNAL)
        return true;
    // 对应的节点状态是 CANCELLED，直接跳过
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 剩余的情况都会将前驱节点的状态置为 SIGNAL
        // 这样在下一次自旋时就会返回 true，进入阻塞，也就是自旋两次的由来
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}