关于java:阅读-JDK-8-源码AQS-中的独占模式

AbstractQueuedSynchronizer，简称 AQS，是一个用于构建锁和同步器的框架。
JUC 包下常见的锁工具如 ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch 都是基于 AQS 实现的。
本文将介绍 AQS 的数据结构及独占模式的实现原理。

AQS 所有操作都围绕着同步资源（synchronization state）来开展，解决了资源拜访的互斥和同步问题。

反对独占、共享形式来拜访资源。
对于无奈获取资源的线程，在同步队列中期待，直到获取资源胜利（或超时、中断）并出队。
线程胜利获取资源之后，若指定条件不成立，则开释资源并进入条件队列中期待，直到被唤醒，再转移到同步队列中期待再次获取资源。

AQS 框架将剩下的一个问题留给用户：获取、开释资源的具体形式和后果。
这其实是一种典型的模板办法设计模式：父类（AQS 框架）定义好骨架和外部操作细节，具体规定由子类去实现。

AbstractQueuedSynchronizer 继承 AbstractOwnableSynchronizer，后者具备属性 exclusiveOwnerThread，用于记录独占模式下取得锁的线程。

public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
    /**
     * The current owner of exclusive mode synchronization.
     */
    private transient Thread exclusiveOwnerThread;
}

AbstractQueuedSynchronizer 具备 ConditionObject 和 Node 两个外部类。
ConditionObject 是对 Condition 接口的实现，能够与 Lock 配合应用。
Node 是 AQS 中同步队列、条件队列的节点。

AQS 定义了一系列模板办法如下：

// 独占获取（资源数）protected boolean tryAcquire(int arg) {throw new UnsupportedOperationException();
}

// 独占开释（资源数）protected boolean tryRelease(int arg) {throw new UnsupportedOperationException();
}

// 共享获取（资源数）protected int tryAcquireShared(int arg) {throw new UnsupportedOperationException();
}

// 共享获取（资源数）protected boolean tryReleaseShared(int arg) {throw new UnsupportedOperationException();
}

// 是否排它状态
protected boolean isHeldExclusively() {throw new UnsupportedOperationException();
}

Java 中罕用的锁工具都是基于 AQS 来实现的。

锁和资源是同一个概念，是多个线程抢夺的对象。
AQS 应用 state 来示意资源 / 锁，通过内置的期待队列来实现获取资源 / 锁的排队工作。
期待队列（wait queue）是严格的 FIFO 队列，是 CLH 锁队列的变种。

因为 state 是共享的，应用 volatile 来保障其可见性，并提供了 getState/setState/compareAndSetState 三个办法来操作 state。

/**
 * The synchronization state.
 */                          
private volatile int state;// 资源 / 锁

/**
 * Returns the current value of synchronization state.
 * This operation has memory semantics of a {@code volatile} read.
 * @return current state value
 */
protected final int getState() {return state;}

/**
 * Sets the value of synchronization state.
 * This operation has memory semantics of a {@code volatile} write.
 * @param newState the new state value
 */
protected final void setState(int newState) {state = newState;}

/**
 * Atomically sets synchronization state to the given updated
 * value if the current state value equals the expected value.
 * This operation has memory semantics of a {@code volatile} read
 * and write.
 *
 * @param expect the expected value
 * @param update the new value
 * @return {@code true} if successful. False return indicates that the actual
 *         value was not equal to the expected value.
 */
protected final boolean compareAndSetState(int expect, int update) { // 原子操作
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

AQS 的外部实现了两个队列：同步队列和条件队列。这两种队列都应用了 Node 作为节点。

节点的定义次要蕴含三局部内容：

节点的状态：SIGNAL、CANCELLED、CONDITION、PROPAGATE、0。
节点的模式：同步队列中的节点具备两种模式，独占（SHARED）、共享（EXCLUSIVE）。
节点的指向：同步队列是双向链表（prev/next），条件队列是单向链表（nextWaiter）。

节点的状态

CANCELLED：值为 1，示意以后节点因为超时或中断被勾销。
SIGNAL：值为 -1，唤醒信号，示意以后节点的后继节点正在期待获取锁。该状态下的节点在 release 或 cancel 时须要执行 unpark 来唤醒后继节点。
CONDITION：值为 -2，示意以后节点为条件队列节点，同步队列的节点不会有这个状态。当节点从条件队列转移到同步队列时，状态会初始化为 0。
PROPAGATE：值为 -3，只有共享模式下，同步队列的头节点才会设置为该状态（见 doReleaseShared），示意后继节点能够发动获取共享资源的操作。
0：初始状态，示意以后节点在同步队列中，期待获取锁。

java.util.concurrent.locks.AbstractQueuedSynchronizer.Node

static final class Node {
    /** Marker to indicate a node is waiting in shared mode */
    static final Node SHARED = new Node();
    /** Marker to indicate a node is waiting in exclusive mode */
    static final Node EXCLUSIVE = null;

    /** waitStatus value to indicate thread has cancelled */
    static final int CANCELLED =  1;
    /** waitStatus value to indicate successor's thread needs unparking */
    static final int SIGNAL    = -1;
    /** waitStatus value to indicate thread is waiting on condition */
    static final int CONDITION = -2;
    /** waitStatus value to indicate the next acquireShared should unconditionally propagate */ 
    static final int PROPAGATE = -3;

    // 期待状态：SIGNAL、CANCELLED、CONDITION、PROPAGATE、0
    volatile int waitStatus;

    // 指向同步队列中的上一个节点
    volatile Node prev;

    // 指向同步队列中的下一个节点
    volatile Node next;

    volatile Thread thread;

    // 在同步队列中，nextWaiter 用于标记节点的模式：独占、共享
    // 在条件队列中，nextWaiter 指向条件队列中的下一个节点
    Node nextWaiter;

    /**
     * Returns true if node is waiting in shared mode.
     */
    // 节点模式是否为共享
    final boolean isShared() {return nextWaiter == SHARED;}

    /**
     * Returns previous node, or throws NullPointerException if null.
     * Use when predecessor cannot be null.  The null check could
     * be elided, but is present to help the VM.
     *
     * @return the predecessor of this node
     */
    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 addWaiter
        this.nextWaiter = mode;          
        this.thread = thread;
    }

    Node(Thread thread, int waitStatus) { // Used by Condition
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

同步队列是期待获取锁的队列，是一个双向链表（prev/next），应用 head/tail 执行队列的首尾节点。

java.util.concurrent.locks.AbstractQueuedSynchronizer

/**
 * Head of the wait queue, lazily initialized.  Except for         
 * initialization, it is modified only via method setHead.  Note:
 * If head exists, its waitStatus is guaranteed not to be          
 * CANCELLED.
 */
// 期待队列的头节点，懒初始化。// 留神，如果头节点存在，那么它的 waitStatus 肯定不是 CANCELLED
private transient volatile Node head;

/**
 * Tail of the wait queue, lazily initialized.  Modified only via  
 * method enq to add new wait node.                                
 */
// 期待队列的尾节点，懒初始化。// 只能通过 enq 办法给期待队列增加新的节点。private transient volatile Node tail;

/**
 * The synchronization state.
 */
private volatile int state;

在线程尝试获取资源失败后，会进入同步队列队尾，给前继节点设置一个唤醒信号后，通过 LockSupport.park(this) 让本身进入期待状态，直到被前继节点唤醒。

当线程在同步队列中期待，获取资源胜利后，通过执行 setHead(node) 将本身设为头节点。
同步队列的头节点是一个 dummy node，它的 thread 为空（某些状况下能够看做是代表了以后持有锁的线程）。

/**
 * Sets head of queue to be node, thus dequeuing. Called only by
 * acquire methods.  Also nulls out unused fields for sake of GC
 * and to suppress unnecessary signals and traversals.
 *
 * @param node the node
 */
private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

AQS 不会在初始化队列的时候构建空的头节点（dummy node），而是在第一次产生争用时结构：
第一个线程获取锁，第二个线程获取锁失败入队，此时才会初始化队列，结构空节点并将 head/tail 指向该空节点。
具体见 AbstractQueuedSynchronizer#enq。

条件队列是期待条件成立的队列，是一个单向链表（nextWaiter），应用 firstWaiter/lastWaiter 指向队列的首尾节点。

java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject

/** First node of condition queue. */
private transient Node firstWaiter; // 条件队列的头节点
/** Last node of condition queue. */
private transient Node lastWaiter;  // 条件队列的尾节点

当线程获取锁胜利之后，执行 Conition.await()，开释锁并进入条件队列中期待，直到其余线程执行 Conition.signal 唤醒以后线程。

以后线程被唤醒后，从条件队列转移到同步队列，从新期待获取锁。

独占模式下，只有有一个线程占有锁，其余线程试图获取该锁将无奈取得成功。

独占模式下获取锁 / 资源，忽视中断，Lock#lock 的外部实现

java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire

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

tryAcquire：尝试间接获取资源 / 锁，如果胜利则间接返回，失败进入下一步；
addWaiter：获取资源 / 锁失败后，将以后线程退出同步队列的尾部，并标记为独占模式，返回新入队的节点；
acquireQueued：使线程在同步队列期待获取资源，始终获取到后才返回，如果在期待过程中被中断过，则返回 true，否则返回 false。
selfInterrupt：如果线程在期待过程中被中断过，在获取资源胜利之后，把中断状态补上。

尝试获取资源，胜利返回 true。具体资源获取形式交由自定义同步器实现。

java.util.concurrent.locks.AbstractQueuedSynchronizer#tryAcquire

protected boolean tryAcquire(int arg) {throw new UnsupportedOperationException();
}

获取资源 / 锁失败后，将以后线程封装为新的节点，设置节点的模式（独占、共享），退出同步队列的尾部，返回该新节点。

java.util.concurrent.locks.AbstractQueuedSynchronizer#addWaiter

/**
 * 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 = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) { // 设置新的尾节点
            pred.next = node;
            return node;
        }
    }
    enq(node); // tail 为空，入队
    return node; // 返回以后的新节点
}

从同步队列的尾部入队，如果队列不存在则进行初始化。

java.util.concurrent.locks.AbstractQueuedSynchronizer#enq

/**
 * Inserts node into queue, initializing if necessary. See picture above.
 * @param node the node to insert
 * @return node's predecessor
 */
private Node enq(final Node node) { // 从同步队列的尾部入队
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize   // 队列为空，则创立一个空节点，作头节点
            if (compareAndSetHead(new Node()))
                tail = head;                  // 初始化实现后并没有返回，而是进行下一次循环
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) { // 队列不为空，则以后节点作为新的 tail // CAS 失败，可能会呈现尾分叉的景象，由下一次循环打消分叉
                t.next = node;                // 因为不是原子操作，入队操作先设置 prev 指针，再设置 next 指针，会导致并发状况下无奈通过 next 遍历到尾节点
                return t;                     // 返回以后节点的上一个节点（旧的尾节点）}
        }
    }
}

留神：

当第一次产生争用时，抢夺锁失败的线程入队，会先结构空节点（dummy node）作为 head/tail 节点进行初始化队列，再从队列尾部入队。
入队时，顺次设置 node.prev、tail、pred.next 指针，是非原子操作。
设置 prev 之后，若 CAS 设置 tail 失败，阐明其余线程先一步入队了，此时进入下一次循环会修改 prev 的指向。
因为入队是非原子操作，并发状况下可能无奈从 head 开始通过 next 遍历到尾节点 tail，然而从尾节点 tail 开始通过 prev 向前遍历能够拜访到残缺的队列。

在同步队列自旋、期待获取资源直到胜利，返回期待期间的中断状态。

java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireQueued

/**
 * Acquires in exclusive uninterruptible mode for thread already in
 * queue. Used by condition wait methods as well as acquire.
 *
 * @param node the node
 * @param arg the acquire argument
 * @return {@code true} if interrupted while waiting
 */
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) { // 上一个节点如果是头结点，阐明以后节点的线程能够尝试获取锁资源
                // 获取锁胜利，以后节点作为新的头节点，并且清理掉以后节点中的线程信息（也就是说头节点是个 dummy node）// 这里不会产生争用，不须要 CAS
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 上一个节点不是头节点，或者以后节点的线程获取锁失败，须要判断是否进入阻塞：// 1. 不能进入阻塞，则重试获取锁。2. 进入阻塞
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt()) // 阻塞以后线程，当从阻塞中被唤醒时，检测以后线程是否已中断，并革除中断状态。接着持续重试获取锁。interrupted = true;      // 标记以后线程已中断（如果线程在阻塞时被中断唤醒，会重试获取锁直到胜利之后，再响应中断）}
    } finally {if (failed)              // 自旋获取锁和阻塞过程中产生异样
            cancelAcquire(node); // 勾销获取锁
    }
}

在 acquireQueued 办法中，线程在自旋中次要进行两个判断：

是否获取锁
是否进入阻塞

具体代码流程：

在同步队列中自旋，若判断前继节点为头节点，则以后节点尝试获取锁。
若以后线程获取锁胜利，则将以后节点设为头节点，返回以后线程的中断状态。
若以后线程无奈获取锁、获取锁失败，则判断是否进入阻塞。
如果无奈进入阻塞，则持续自旋，否则进入阻塞。
线程从阻塞中被唤醒后，查看并标记线程的中断状态，从新进入自旋。

以后节点获取锁失败之后，通过校验上一个节点的期待状态，判断以后节点是否进入阻塞。
返回 true，可进入阻塞；返回 false，不可进入阻塞，需重试获取锁。

java.util.concurrent.locks.AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire

/**
 * Checks and updates status for a node that failed to acquire. 
 * Returns true if thread should block. This is the main signal
 * control in all acquire loops.  Requires that pred == node.prev.
 *
 * @param pred node's predecessor holding status
 * @param node the node
 * @return {@code true} if thread should block
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release // 以后节点曾经给它的上一个节点设置了唤醒信号
         * to signal it, so it can safely park.              // 以后节点能够进入阻塞
         */
        return true;
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and // 上一个节点状态大于 0，阐明是已勾销状态 CANCELLED，不会告诉以后节点
         * indicate retry.                                       // 则始终往前找到一个期待状态的节点，并排在它的后边
         */                                                      // 以后节点不能进入阻塞，需重试获取锁
        do {node.prev = pred = pred.prev; // pred = pred.prev; node.prev = pred; // 跳过上一个节点，直到找到 waitStatus > 0 的节点} while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we    // 上一个节点状态等于 0 或 PROPAGATE，阐明正在期待获取锁 / 资源
         * need a signal, but don't park yet.  Caller will need to // 此时须要给上一个节点设置唤醒信号 SIGNAL，但不间接阻塞
         * retry to make sure it cannot acquire before parking.    // 因为在阻塞前调用者须要重试来确认它的确不能获取资源
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL); // 通过 CAS 将上一个节点的状态改为 SIGNAL
    }
    return false;
}

以后节点可能进入阻塞的条件是：具备其余线程来唤醒它。
通过设置上一个节点状态为 SIGNAL，以确保上一个节点在开释锁之后，可能唤醒以后节点。

分为三种状况：

上一个节点状态为 Node.SIGNAL，阐明以后节点已具备被唤醒的条件，能够进入阻塞。
上一个节点状态为已勾销，则把以后节点排到未勾销的节点前面，持续自旋不进入阻塞。
上一个节点状态为 0 或 PROPAGATE，阐明正在期待获取锁，则以后节点将上一个节点设为 SIGNAL，持续自旋不进入阻塞。

进入阻塞，阻塞完结后，查看中断状态。

java.util.concurrent.locks.AbstractQueuedSynchronizer#parkAndCheckInterrupt

/**
 * Convenience method to park and then check if interrupted
 *
 * @return {@code true} if interrupted
 */
private final boolean parkAndCheckInterrupt() {LockSupport.park(this);
    return Thread.interrupted();}

线程在 acquireQueued 中自旋尝试获取锁的过程中，如果产生异样，会在 finally 代码块中执行 cancelAcquire，终止获取锁。

/**
 * Cancels an ongoing attempt to acquire.
 *
 * @param node the node
 */
private void cancelAcquire(Node node) { // 勾销获取锁
    // Ignore if node doesn't exist
    if (node == null)
        return;

    node.thread = null;

    // Skip cancelled predecessors // 跳过已勾销的前继节点，为以后节点找出一个无效的前继节点
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    // predNext is the apparent node to unsplice. CASes below will
    // fail if not, in which case, we lost race vs another cancel
    // or signal, so no further action is necessary.
    Node predNext = pred.next;

    // Can use unconditional write instead of CAS here.        // 写操作具备可见性（volatile），因而这里无需应用 CAS
    // After this atomic step, other Nodes can skip past us.   // 把以后节点设为已勾销之后，其余节点寻找无效前继节点时会跳过以后节点
    // Before, we are free of interference from other threads.
    node.waitStatus = Node.CANCELLED;

    // If we are the tail, remove ourselves.
    if (node == tail && compareAndSetTail(node, pred)) { // 如果是尾节点，则出队
        compareAndSetNext(pred, predNext, null);
    } else {                                                      // 进入这里，阐明不是尾节点，或者是尾节点但出队失败，须要解决后继节点
        // If successor needs signal, try to set pred's next-link // 如果后继节点须要失去告诉，则尝试给它找一个新的前继节点
        // so it will get one. Otherwise wake it up to propagate. // 否则把后继节点唤醒
        int ws;
        if (pred != head &&                                       // 前继节点不是头节点
            ((ws = pred.waitStatus) == Node.SIGNAL ||             // 前继节点的状态为 SIGNAL 或者 前继节点的状态为未勾销且尝试设置为 SIGNAL 胜利
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)    // 后继节点存在且未勾销
                compareAndSetNext(pred, predNext, next); // 给后继节点设置一个新的前继节点（即后面找的无效节点），以后节点出队
        } else {unparkSuccessor(node); // 如果存在后继节点，这里阐明无奈给后继节点找到新的前继节点（可能前继节点是 head，或者前继节点生效了），间接唤醒该后继节点
        }

        node.next = node; // help GC
    }
}

节点 node 勾销获取锁，阐明以后节点 node 状态变为已勾销，成为一个有效节点。

须要思考如何解决节点 node 的后继节点：

无后继节点，则须要将最初一个无效节点（waitStatus <= 0）设为 tail。
存在后继节点，则须要将它挂在最初的无效节点之后，后续由该节点来唤醒后继节点。
存在后继节点，且找不到无效的前继节点，则间接把该后继节点唤醒。

唤醒以后节点的后继节点。

java.util.concurrent.locks.AbstractQueuedSynchronizer#unparkSuccessor

/**
 * Wakes up node's successor, if one exists.
 *
 * @param node the node
 */
// 唤醒以后节点的后继节点 
private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus; // 如果以后节点的状态为已勾销，则不变；如果小于 0（有可能后继节点须要以后节点来唤醒），则清零。if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0); // CAS 失败也无所谓（阐明后继节点的线程先一步批改了以后节点的状态），因为接下来会手动唤醒后继节点

    Node s = node.next;
    if (s == null || s.waitStatus > 0) { // 后继节点为空，或已勾销，则从 tail 开始向前遍历无效节点
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t; // // 留神! 这里找到了之后并没有 return, 而是持续向前找
    }
    if (s != null)
        LockSupport.unpark(s.thread); // 唤醒后继节点（或者是队列中距离 head 节点最近的无效节点）的线程
}

通常状况下, 要唤醒的节点就是本人的后继节点。如果后继节点存在且也在期待锁, 那就间接唤醒它。
然而有可能存在后继节点勾销期待锁的状况，此时从尾节点开始向前找起, 直到找到间隔 head 节点最近的未勾销的节点，对它进行唤醒。

为什么不从以后节点向后遍历无效节点呢？

以后节点可能是尾节点，不存在后继节点。
入队时先设置 prev 指针，再设置 next 指针（见 AbstractQueuedSynchronizer#enq），是非原子操作，依据 prev 指针往前遍历比拟精确。

比照 acquire，两者对获取锁过程中产生中断的解决不同。

acquire 期待锁的过程产生中断，会等到获取锁胜利之后，再解决中断。
acquireInterruptibly 期待锁的过程产生中断，会立刻抛出 InterruptedException，不再期待获取锁。

java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireInterruptibly

public final void acquireInterruptibly(int arg)
        throws InterruptedException {if (Thread.interrupted())
        throw new InterruptedException();
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

java.util.concurrent.locks.AbstractQueuedSynchronizer#doAcquireInterruptibly

/**
 * Acquires in exclusive interruptible mode.
 * @param arg the acquire argument
 */
private void doAcquireInterruptibly(int arg)
    throws InterruptedException {final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {for (;;) {final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {setHead(node);
                p.next = null; // help GC
                failed = false;
                return;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException(); // 线程在阻塞期待锁的过程中，被中断唤醒，则放弃期待锁，间接抛出异样}
    } finally {if (failed)
            cancelAcquire(node);
    }
}

独占模式下开释锁 / 资源，是 Lock#unlock 的外部实现。

java.util.concurrent.locks.AbstractQueuedSynchronizer#release

public final boolean release(int arg) {if (tryRelease(arg)) { // 开释锁资源
        Node h = head;
        if (h != null && h.waitStatus != 0) // head.waitStatus == 0，阐明 head 节点后没有须要唤醒的节点
            unparkSuccessor(h); // 唤醒 head 的后继节点
        return true;
    }
    return false;
}

tryRelease：开释锁资源，开释胜利则进入下一步。
unparkSuccessor：如果同步队列的头节点存在且满足 waitStatus != 0，则唤醒后继节点。

java.util.concurrent.locks.AbstractQueuedSynchronizer#tryRelease

protected boolean tryRelease(int arg) {throw new UnsupportedOperationException();
}

头节点 h 的状态：

h.waitStatus == 0，同步队列中的节点初始状态为 0，阐明没有须要唤醒的后继节点。
h.waitStatus < 0，独占模式下，阐明是 SIGNAL 状态，此时具备后继节点期待唤醒，见 AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire。
h.waitStatus > 0，阐明是 CANCELLED 状态，头节点是由勾销获取锁的节点而来的，保险起见，查看有没有须要唤醒的后继节点。

相干浏览：
浏览 JDK 8 源码：AQS 中的独占模式
浏览 JDK 8 源码：AQS 中的共享模式
浏览 JDK 8 源码：AQS 对 Condition 的实现

作者：Sumkor

关于java:阅读-JDK-8-源码AQS-中的独占模式

1. AQS 框架

1.1 继承体系

1.2 模板办法

2. 数据结构

2.1 资源定义

2.2 节点定义

2.3 同步队列

2.4 条件队列

3. 独占模式

3.1 获取锁 -acquire

3.1.1 tryAcquire

3.1.2 addWaiter

enq

3.1.3 acquireQueued

shouldParkAfterFailedAcquire

parkAndCheckInterrupt

cancelAcquire

unparkSuccessor

3.2 获取锁 -acquireInterruptibly

3.3 开释锁 -release