JUC锁: 锁核心类AQS详解

前几天已经总结过AQS的相关知识点。但是总感觉学的不够扎实，今天根据网上的blog在此进行总结。

什么是AQS、为什么它是核心？

AQS是用来构造锁和同步器的框架，中文队列同步器。在java中有很多的同步器都是由AQS作为基础核心的。比如：ReentrantLock、Semaphore等等。程序员也可以自己利用AQS定义符合自己需求的同步器。

AQS的和核心思想？底层数据结构是什么？

核心思想：

**宏观：**AQS的核心思想是，如果一个线程正在请求一个空闲的共享资源，那么AQS则将当前线程设置为有效地工作线程，并且将共享资源设置为锁定状态。当线程请求的共享资源呈现锁定状态，这说明此资源正在被其他线程使用，那么AQS提供了基于CLH虚拟双端队列的线程等待和唤醒操作，即将暂时获取不到锁的线程资源放入队列尾，进行自旋等待。

底层数据结构：

这张图是在网上的blog上拿下来的，跟java并发编程艺术这本书上稍稍有些出入，书中并没有提到Condition Queue这个数据结构。Condition queue这是属于Condition的内容。此处进行了结合。

AQS的底层数据结构主要是使用的CLH虚拟双向队列，队列中保存了节点之间的关系。AQS将每条请求共享资源的线程封装成队列的节点结构Node，如果请求锁失败则加入队列的尾部，并实现节点的自旋操作。如果当前节点的前驱结点是首(头)节点，并且其获取锁成功，则此时释放首节点，阻塞其他线程的请求。

上图中的Condition Queue只有在使用了Condition的时候才会存在。

从源码角度分析AQS底层：

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable

AbstractQueuedSynchronizer继承自AbstractOwnableSynchronizer抽象类，并且实现了Serializable接口，可以进行序列化。

AQS源代码中主要包括两个内部类——Node、ConditionObject类

内部类Node

static final class Node {// 模式，分为共享与独占// 共享模式static final Node SHARED = new Node();// 独占模式static final Node EXCLUSIVE = null;        // 结点状态// CANCELLED，值为1，表示当前的线程被取消// SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark// CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队列中// PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行// 值为0，表示当前节点在sync队列中，等待着获取锁static final int CANCELLED =  1;static final int SIGNAL    = -1;static final int CONDITION = -2;static final int PROPAGATE = -3;        // 结点状态volatile int waitStatus;        // 前驱结点volatile Node prev;    // 后继结点volatile Node next;        // 结点所对应的线程volatile Thread thread;        // 下一个等待者Node nextWaiter;// 结点是否在共享模式下等待final boolean isShared() {return nextWaiter == SHARED;}// 获取前驱结点，若前驱结点为空，抛出异常final Node predecessor() throws NullPointerException {// 保存前驱结点Node p = prev; if (p == null) // 前驱结点为空，抛出异常throw new NullPointerException();else // 前驱结点不为空，返回return p;}// 无参构造方法Node() {    // Used to establish initial head or SHARED marker}// 构造方法Node(Thread thread, Node mode) {    // Used by addWaiterthis.nextWaiter = mode;this.thread = thread;}// 构造方法Node(Thread thread, int waitStatus) { // Used by Conditionthis.waitStatus = waitStatus;this.thread = thread;}
}

内部类ConditionObject类：

// 内部类
public class ConditionObject implements Condition, java.io.Serializable {// 版本号private static final long serialVersionUID = 1173984872572414699L;/** First node of condition queue. */// condition队列的头结点private transient Node firstWaiter;/** Last node of condition queue. */// condition队列的尾结点private transient Node lastWaiter;/*** Creates a new {@code ConditionObject} instance.*/// 构造方法public ConditionObject() { }// Internal methods/*** Adds a new waiter to wait queue.* @return its new wait node*/// 添加新的waiter到wait队列private Node addConditionWaiter() {// 保存尾结点Node t = lastWaiter;// If lastWaiter is cancelled, clean out.if (t != null && t.waitStatus != Node.CONDITION) { // 尾结点不为空，并且尾结点的状态不为CONDITION// 清除状态为CONDITION的结点unlinkCancelledWaiters(); // 将最后一个结点重新赋值给tt = lastWaiter;}// 新建一个结点Node node = new Node(Thread.currentThread(), Node.CONDITION);if (t == null) // 尾结点为空// 设置condition队列的头结点firstWaiter = node;else // 尾结点不为空// 设置为节点的nextWaiter域为node结点t.nextWaiter = node;// 更新condition队列的尾结点lastWaiter = node;return node;}/*** Removes and transfers nodes until hit non-cancelled one or* null. Split out from signal in part to encourage compilers* to inline the case of no waiters.* @param first (non-null) the first node on condition queue*/private void doSignal(Node first) {// 循环do {if ( (firstWaiter = first.nextWaiter) == null) // 该节点的nextWaiter为空// 设置尾结点为空lastWaiter = null;// 设置first结点的nextWaiter域first.nextWaiter = null;} while (!transferForSignal(first) &&(first = firstWaiter) != null); // 将结点从condition队列转移到sync队列失败并且condition队列中的头结点不为空，一直循环}/*** Removes and transfers all nodes.* @param first (non-null) the first node on condition queue*/private void doSignalAll(Node first) {// condition队列的头结点尾结点都设置为空lastWaiter = firstWaiter = null;// 循环do {// 获取first结点的nextWaiter域结点Node next = first.nextWaiter;// 设置first结点的nextWaiter域为空first.nextWaiter = null;// 将first结点从condition队列转移到sync队列transferForSignal(first);// 重新设置firstfirst = next;} while (first != null);}/*** Unlinks cancelled waiter nodes from condition queue.* Called only while holding lock. This is called when* cancellation occurred during condition wait, and upon* insertion of a new waiter when lastWaiter is seen to have* been cancelled. This method is needed to avoid garbage* retention in the absence of signals. So even though it may* require a full traversal, it comes into play only when* timeouts or cancellations occur in the absence of* signals. It traverses all nodes rather than stopping at a* particular target to unlink all pointers to garbage nodes* without requiring many re-traversals during cancellation* storms.*/// 从condition队列中清除状态为CANCEL的结点private void unlinkCancelledWaiters() {// 保存condition队列头结点Node t = firstWaiter;Node trail = null;while (t != null) { // t不为空// 下一个结点Node next = t.nextWaiter;if (t.waitStatus != Node.CONDITION) { // t结点的状态不为CONDTION状态// 设置t节点的额nextWaiter域为空t.nextWaiter = null;if (trail == null) // trail为空// 重新设置condition队列的头结点firstWaiter = next;else // trail不为空// 设置trail结点的nextWaiter域为next结点trail.nextWaiter = next;if (next == null) // next结点为空// 设置condition队列的尾结点lastWaiter = trail;}else // t结点的状态为CONDTION状态// 设置trail结点trail = t;// 设置t结点t = next;}}// public methods/*** Moves the longest-waiting thread, if one exists, from the* wait queue for this condition to the wait queue for the* owning lock.** @throws IllegalMonitorStateException if {@link #isHeldExclusively}*         returns {@code false}*/// 唤醒一个等待线程。如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取锁。public final void signal() {if (!isHeldExclusively()) // 不被当前线程独占，抛出异常throw new IllegalMonitorStateException();// 保存condition队列头结点Node first = firstWaiter;if (first != null) // 头结点不为空// 唤醒一个等待线程doSignal(first);}/*** Moves all threads from the wait queue for this condition to* the wait queue for the owning lock.** @throws IllegalMonitorStateException if {@link #isHeldExclusively}*         returns {@code false}*/// 唤醒所有等待线程。如果所有的线程都在等待此条件，则唤醒所有线程。在从 await 返回之前，每个线程都必须重新获取锁。public final void signalAll() {if (!isHeldExclusively()) // 不被当前线程独占，抛出异常throw new IllegalMonitorStateException();// 保存condition队列头结点Node first = firstWaiter;if (first != null) // 头结点不为空// 唤醒所有等待线程doSignalAll(first);}/*** Implements uninterruptible condition wait.* <ol>* <li> Save lock state returned by {@link #getState}.* <li> Invoke {@link #release} with saved state as argument,*      throwing IllegalMonitorStateException if it fails.* <li> Block until signalled.* <li> Reacquire by invoking specialized version of*      {@link #acquire} with saved state as argument.* </ol>*/// 等待，当前线程在接到信号之前一直处于等待状态，不响应中断public final void awaitUninterruptibly() {// 添加一个结点到等待队列Node node = addConditionWaiter();// 获取释放的状态int savedState = fullyRelease(node);boolean interrupted = false;while (!isOnSyncQueue(node)) { // // 阻塞当前线程LockSupport.park(this);if (Thread.interrupted()) // 当前线程被中断// 设置interrupted状态interrupted = true; }if (acquireQueued(node, savedState) || interrupted) // selfInterrupt();}/** For interruptible waits, we need to track whether to throw* InterruptedException, if interrupted while blocked on* condition, versus reinterrupt current thread, if* interrupted while blocked waiting to re-acquire.*//** Mode meaning to reinterrupt on exit from wait */private static final int REINTERRUPT =  1;/** Mode meaning to throw InterruptedException on exit from wait */private static final int THROW_IE    = -1;/*** Checks for interrupt, returning THROW_IE if interrupted* before signalled, REINTERRUPT if after signalled, or* 0 if not interrupted.*/private int checkInterruptWhileWaiting(Node node) {return Thread.interrupted() ?(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :0; }/*** Throws InterruptedException, reinterrupts current thread, or* does nothing, depending on mode.*/private void reportInterruptAfterWait(int interruptMode)throws InterruptedException {if (interruptMode == THROW_IE)throw new InterruptedException();else if (interruptMode == REINTERRUPT)selfInterrupt();}/*** Implements interruptible condition wait.* <ol>* <li> If current thread is interrupted, throw InterruptedException.* <li> Save lock state returned by {@link #getState}.* <li> Invoke {@link #release} with saved state as argument,*      throwing IllegalMonitorStateException if it fails.* <li> Block until signalled or interrupted.* <li> Reacquire by invoking specialized version of*      {@link #acquire} with saved state as argument.* <li> If interrupted while blocked in step 4, throw InterruptedException.* </ol>*/// // 等待，当前线程在接到信号或被中断之前一直处于等待状态public final void await() throws InterruptedException {if (Thread.interrupted()) // 当前线程被中断，抛出异常throw new InterruptedException();// 在wait队列上添加一个结点Node node = addConditionWaiter();// int savedState = fullyRelease(node);int interruptMode = 0;while (!isOnSyncQueue(node)) {// 阻塞当前线程LockSupport.park(this);if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) // 检查结点等待时的中断类型break;}if (acquireQueued(node, savedState) && interruptMode != THROW_IE)interruptMode = REINTERRUPT;if (node.nextWaiter != null) // clean up if cancelledunlinkCancelledWaiters();if (interruptMode != 0)reportInterruptAfterWait(interruptMode);}/*** Implements timed condition wait.* <ol>* <li> If current thread is interrupted, throw InterruptedException.* <li> Save lock state returned by {@link #getState}.* <li> Invoke {@link #release} with saved state as argument,*      throwing IllegalMonitorStateException if it fails.* <li> Block until signalled, interrupted, or timed out.* <li> Reacquire by invoking specialized version of*      {@link #acquire} with saved state as argument.* <li> If interrupted while blocked in step 4, throw InterruptedException.* </ol>*/// 等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态 public final long awaitNanos(long nanosTimeout)throws InterruptedException {if (Thread.interrupted())throw new InterruptedException();Node node = addConditionWaiter();int savedState = fullyRelease(node);final long deadline = System.nanoTime() + nanosTimeout;int interruptMode = 0;while (!isOnSyncQueue(node)) {if (nanosTimeout <= 0L) {transferAfterCancelledWait(node);break;}if (nanosTimeout >= spinForTimeoutThreshold)LockSupport.parkNanos(this, nanosTimeout);if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)break;nanosTimeout = deadline - System.nanoTime();}if (acquireQueued(node, savedState) && interruptMode != THROW_IE)interruptMode = REINTERRUPT;if (node.nextWaiter != null)unlinkCancelledWaiters();if (interruptMode != 0)reportInterruptAfterWait(interruptMode);return deadline - System.nanoTime();}/*** Implements absolute timed condition wait.* <ol>* <li> If current thread is interrupted, throw InterruptedException.* <li> Save lock state returned by {@link #getState}.* <li> Invoke {@link #release} with saved state as argument,*      throwing IllegalMonitorStateException if it fails.* <li> Block until signalled, interrupted, or timed out.* <li> Reacquire by invoking specialized version of*      {@link #acquire} with saved state as argument.* <li> If interrupted while blocked in step 4, throw InterruptedException.* <li> If timed out while blocked in step 4, return false, else true.* </ol>*/// 等待，当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态public final boolean awaitUntil(Date deadline)throws InterruptedException {long abstime = deadline.getTime();if (Thread.interrupted())throw new InterruptedException();Node node = addConditionWaiter();int savedState = fullyRelease(node);boolean timedout = false;int interruptMode = 0;while (!isOnSyncQueue(node)) {if (System.currentTimeMillis() > abstime) {timedout = transferAfterCancelledWait(node);break;}LockSupport.parkUntil(this, abstime);if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)break;}if (acquireQueued(node, savedState) && interruptMode != THROW_IE)interruptMode = REINTERRUPT;if (node.nextWaiter != null)unlinkCancelledWaiters();if (interruptMode != 0)reportInterruptAfterWait(interruptMode);return !timedout;}/*** Implements timed condition wait.* <ol>* <li> If current thread is interrupted, throw InterruptedException.* <li> Save lock state returned by {@link #getState}.* <li> Invoke {@link #release} with saved state as argument,*      throwing IllegalMonitorStateException if it fails.* <li> Block until signalled, interrupted, or timed out.* <li> Reacquire by invoking specialized version of*      {@link #acquire} with saved state as argument.* <li> If interrupted while blocked in step 4, throw InterruptedException.* <li> If timed out while blocked in step 4, return false, else true.* </ol>*/// 等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。此方法在行为上等效于: awaitNanos(unit.toNanos(time)) > 0public final boolean await(long time, TimeUnit unit)throws InterruptedException {long nanosTimeout = unit.toNanos(time);if (Thread.interrupted())throw new InterruptedException();Node node = addConditionWaiter();int savedState = fullyRelease(node);final long deadline = System.nanoTime() + nanosTimeout;boolean timedout = false;int interruptMode = 0;while (!isOnSyncQueue(node)) {if (nanosTimeout <= 0L) {timedout = transferAfterCancelledWait(node);break;}if (nanosTimeout >= spinForTimeoutThreshold)LockSupport.parkNanos(this, nanosTimeout);if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)break;nanosTimeout = deadline - System.nanoTime();}if (acquireQueued(node, savedState) && interruptMode != THROW_IE)interruptMode = REINTERRUPT;if (node.nextWaiter != null)unlinkCancelledWaiters();if (interruptMode != 0)reportInterruptAfterWait(interruptMode);return !timedout;}//  support for instrumentation/*** Returns true if this condition was created by the given* synchronization object.** @return {@code true} if owned*/final boolean isOwnedBy(AbstractQueuedSynchronizer sync) {return sync == AbstractQueuedSynchronizer.this;}/*** Queries whether any threads are waiting on this condition.* Implements {@link AbstractQueuedSynchronizer#hasWaiters(ConditionObject)}.** @return {@code true} if there are any waiting threads* @throws IllegalMonitorStateException if {@link #isHeldExclusively}*         returns {@code false}*///  查询是否有正在等待此条件的任何线程protected final boolean hasWaiters() {if (!isHeldExclusively())throw new IllegalMonitorStateException();for (Node w = firstWaiter; w != null; w = w.nextWaiter) {if (w.waitStatus == Node.CONDITION)return true;}return false;}/*** Returns an estimate of the number of threads waiting on* this condition.* Implements {@link AbstractQueuedSynchronizer#getWaitQueueLength(ConditionObject)}.** @return the estimated number of waiting threads* @throws IllegalMonitorStateException if {@link #isHeldExclusively}*         returns {@code false}*/// 返回正在等待此条件的线程数估计值protected final int getWaitQueueLength() {if (!isHeldExclusively())throw new IllegalMonitorStateException();int n = 0;for (Node w = firstWaiter; w != null; w = w.nextWaiter) {if (w.waitStatus == Node.CONDITION)++n;}return n;}/*** Returns a collection containing those threads that may be* waiting on this Condition.* Implements {@link AbstractQueuedSynchronizer#getWaitingThreads(ConditionObject)}.** @return the collection of threads* @throws IllegalMonitorStateException if {@link #isHeldExclusively}*         returns {@code false}*/// 返回包含那些可能正在等待此条件的线程集合protected final Collection<Thread> getWaitingThreads() {if (!isHeldExclusively())throw new IllegalMonitorStateException();ArrayList<Thread> list = new ArrayList<Thread>();for (Node w = firstWaiter; w != null; w = w.nextWaiter) {if (w.waitStatus == Node.CONDITION) {Thread t = w.thread;if (t != null)list.add(t);}}return list;}
}

Condition的具体实现另做分析。不在本片文章中叙述。

AQS类的属性

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizerimplements java.io.Serializable {    // 版本号private static final long serialVersionUID = 7373984972572414691L;    // 头结点private transient volatile Node head;    // 尾结点private transient volatile Node tail;    // 状态private volatile int state;    // 自旋时间static final long spinForTimeoutThreshold = 1000L;// Unsafe类实例private static final Unsafe unsafe = Unsafe.getUnsafe();// state内存偏移地址private static final long stateOffset;// head内存偏移地址private static final long headOffset;// state内存偏移地址private static final long tailOffset;// tail内存偏移地址private static final long waitStatusOffset;// next内存偏移地址private static final long nextOffset;// 静态初始化块 加载内存的偏移地址static {try {stateOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("state"));headOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("head"));tailOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));waitStatusOffset = unsafe.objectFieldOffset(Node.class.getDeclaredField("waitStatus"));nextOffset = unsafe.objectFieldOffset(Node.class.getDeclaredField("next"));} catch (Exception ex) { throw new Error(ex); }}
}

AQS有哪些核心的方法?

AQS中的核心方法在原理上来说就是获取锁和释放锁，但是AQS的获取资源的方式分为独占和共享，所以有两套方法，这里我们先看独占系列的核心方法。

acquire方法

该方法以独占的方式获取资源，此方法对于线程中断不敏感，也就是说线程中断对此方法无效。

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

接下来我们一次看顺序调用的方法：

tryAcquire方法

调用此方法的线程将会在独占模式下获取对象的状态，如果获取成功，则后续语句将不会执行，因为是&&操作符。如果此方法调用失败，表示当前尝试获取的对象资源已经被其他线程占用，那么将会执行后续方法。

addWaiter()方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C3nE1BF6-1600644095337)(C:\Users\30914\AppData\Roaming\Typora\typora-user-images\image-20200907214736976.png)]

/*** Creates and enqueues node for current thread and given mode.** @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared* @return the new node*///添加等待节点private Node addWaiter(Node mode) {//根据当前线程的模式和线程的基本信息构造Node节点Node node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail;//插入尾节点 注意CAS的使用if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}//如果尾节点没有被初始化，则进入end方法死循环添加节点，知道添加成功enq(node);return node;}

enq()方法

private Node enq(final Node node) {for (;;) {Node t = tail;if (t == null) { // Must initialize//如果没有初始化，则先初始化if (compareAndSetHead(new Node()))tail = head;} else {//已经初始化，则直接CAS添加node至尾节点。node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}}

以上这两个方法都在致力于添加线程节点值队列尾部，再添加的过程中，都使用了CAS操作来保证原子性，如果尾节点初始化失败或者CAS再执行的时候出现问题，则调用死循环方法enq，其内部也使用了CAS来添加尾节点，当添加成功后，返回，跳出死循环。

acquireQueued()方法

final boolean acquireQueued(final Node node, int arg) {// 标志boolean failed = true;try {// 中断标志boolean interrupted = false;for (;;) { // 无限循环// 获取node节点的前驱结点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);}
}

当线程被构造成Node节点并添加至队列尾之后，节点并不是什么都不做，或者说java会对其采取动作。这个动作叫自旋，也就是节点不断通过某种方式检测自己是否获得了锁，是否可以执行对应的线程活动。

该方法对应的主要流程为：

• 检查自己的前驱节点是不是头节点，如果是头节点，那么尝试获取锁，如果获取成功，则将当前节点设置为头节点，并断开之前的头节点之间连接，进行GC操作。

• 无论这一步是否成功，程序最终都会调用finally代码块中的代码：

• 如果上述操作失败，则会执行shouldParkAfterFailedAcquire和parkAndCheckInterrupt方法，一起来看源码：

  • // 当获取(资源)失败后，检查并且更新结点状态
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {// 获取前驱结点的状态int ws = pred.waitStatus;if (ws == Node.SIGNAL) // 状态为SIGNAL，为-1/** This node has already set status asking a release* to signal it, so it can safely park.*/// 可以进行park操作return true; if (ws > 0) { // 表示状态为CANCELLED，为1/** Predecessor was cancelled. Skip over predecessors and* indicate retry.*/do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0); // 找到pred结点前面最近的一个状态不为CANCELLED的结点// 赋值pred结点的next域pred.next = node; } else { // 为PROPAGATE -3 或者是0 表示无状态,(为CONDITION -2时，表示此节点在condition queue中) /** waitStatus must be 0 or PROPAGATE.  Indicate that we* need a signal, but don't park yet.  Caller will need to* retry to make sure it cannot acquire before parking.*/// 比较并设置前驱结点的状态为SIGNALcompareAndSetWaitStatus(pred, ws, Node.SIGNAL); }// 不能进行park操作return false;
    } 
    

  • 这个源码的目的是，在线程节点自旋的过程中，判断当前正在执行的线程是否需要阻塞。判断的规则如下：

    • 如果当前线程的前驱结点的状态是SINNAL，则表明当前线程需要阻塞。直接返回true。
    • 如果ws>0，则表明前驱结点状态为CANCELLED，说明此时前驱结点已经超时等待或者被中断了，则需要将这种前驱节点从CLH队列中删除。
    • 如果ws为其他状态值，则通过CAS的方式将前驱结点设置为SINNAL，返回false。
    • 综上，只有当前节点的前驱结点的状态值为SINNAL的时候，才对当前线程进行阻塞。

• 阻塞代码：

  • private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}
    

  • 当shouldParkAfterFailedAcquire方法返回为true，表示当前节点需要阻塞，则调用LockSupport的park方法阻塞当前线程。

release方法：

public final boolean release(int arg) {if (tryRelease(arg)) { // 释放成功// 保存头结点Node h = head; if (h != null && h.waitStatus != 0) // 头结点不为空并且头结点状态不为0unparkSuccessor(h); //释放头结点的后继结点return true;}return false;
}

前驱结点的状态是SINNAL，则表明当前线程需要阻塞。直接返回true。
- 如果ws>0，则表明前驱结点状态为CANCELLED，说明此时前驱结点已经超时等待或者被中断了，则需要将这种前驱节点从CLH队列中删除。
- 如果ws为其他状态值，则通过CAS的方式将前驱结点设置为SINNAL，返回false。
- 综上，只有当前节点的前驱结点的状态值为SINNAL的时候，才对当前线程进行阻塞。

• 阻塞代码：

  • private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}
    

  • 当shouldParkAfterFailedAcquire方法返回为true，表示当前节点需要阻塞，则调用LockSupport的park方法阻塞当前线程。

release方法：

public final boolean release(int arg) {if (tryRelease(arg)) { // 释放成功// 保存头结点Node h = head; if (h != null && h.waitStatus != 0) // 头结点不为空并且头结点状态不为0unparkSuccessor(h); //释放头结点的后继结点return true;}return false;
}