以 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 GCfailed = 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) // overflowthrow 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 GCfailed = 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;
}
