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

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

// 建立初始化 head 或 SHARED 标记会用到
Node() {
}

// addWaiter 会用到
Node(Thread thread, Node mode) { 
    this.nextWaiter = mode;
    this.thread = thread;
}

// Condition 会用到
Node(Thread thread, int waitStatus) {
    this.waitStatus = waitStatus;
    this.thread = thread;
}

private Node addWaiter(Node mode) {
    // 创建一个节点，因为这里是独占式，所以将等待队列设置为null
    Node node = new Node(Thread.currentThread(), mode);
    
    // 获取尾节点，
    Node pred = tail;

    // 如果当前同步队列的尾部不为 null，则尝试将 node 快速添加到同步队列的尾部
    if (pred != null) {

        // node的前节点指向当前同步队列的尾部
        node.prev = pred;

        // 尝试通过 CAS 来将 node 插入到同步队列的尾部
        if (compareAndSetTail(pred, node)) {
            // CAS 成功将 node 设置为 tail 并且将更新前的尾部节点的后继节点指向当前 node 节点。
            pred.next = node;
            return node;
        }
    }

    /** 
     * 执行到 enq(Node) 这里有 2 种情况：
     * 1. tail == null，说明同步队列未初始化
     * 2. 快速插入同步队列失败
     */
    // 通过无限循环配合 CAS 将节点 node 插入到同步队列的尾部
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        // 获取当前同步队列的尾节点
        Node t = tail;
        // 判断尾节点是否初始化
        if (t == null) {

            // 进行初始化同步队列
            if (compareAndSetHead(new Node()))
                // 若成功 CAS，初始化同步器
                tail = head;
        } else {
            // 将 node 的前节点指向当前同步队列的尾节点 tail
            node.prev = t;
            // 尝试 CAS 来将 node 设置为当前同步队列的尾节点 tail
            if (compareAndSetTail(t, node)) {
                // CAS 成功，将 tail 节点的 next 指向现在的 node
                t.next = node;
                return t;
            }
        }
    }
}

// final 修饰node，避免node被重复赋值
/**
 * @param node，注意这个 node 是前面新添加到同步队列中的节点
 */
final boolean acquireQueued(final Node node, int arg) {
    // 获取同步状态是否失败，true为失败，false为成功
    boolean failed = true;
    try {
        // 当前线程是否被中断，true为被中断，flse未被中断
        boolean interrupted = false;

        // 进入无限循环
        for (;;) {
            // 获取当前线程的前节点
            final Node p = node.predecessor();

            // 只有前节点为 head 的时候才有资格去获取同步状态，这样也是为了维护队列的 FIFO 原则
            if (p == head && tryAcquire(arg)) {
                // 成功获取同步状态，将同步队列头部 head 设置为 node，同时释放当前节点不适用的资源
                // 这也是上面示例图中，为什么头节点的 prev 没有指向，因为没有什么用。
                setHead(node);

                // 将旧的头节点从同步队列中脱离出来
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }

            // 代码执行到这里的情况：
            // 1. 获取同步状态失败
            // 2. 前驱节点不是 head 节点
            // 判断当前线程是否需要阻塞（这个是根据其前节点的等待状态来决定的）以及当前线程是否被标记被中断状态
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        // 如果当前线程在获取同步状态的时候出现异常退出的情况，取消获取同步状态
        if (failed)
            cancelAcquire(node);
    }
}

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

/**
 * 检查并更新当前节点以及当前节点的前驱节点的状态
 * @param pred, node 的前驱节点
 * @param node, node 节点
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取前驱节点的等待状态
    int ws = pred.waitStatus;

    // 前驱节点的等待状态为-1，说明前节点正常运行中，当前节点需要被阻塞
    if (ws == Node.SIGNAL)
        return true;
    
    /**
     * 前驱节点的等待状态 > 0
     * 前面我们了解过 Node 的结构，知道等待状态大于 >0 的情况只有为1的时候
     * 这个时候说明前节点已经被取消等待。
     * 面对这种情况，当前节点就需要重新找一个新的前驱节点。
     * 下面的做法就是顺着前驱节点往前找，一直找到 waitstatus < 0 的节点，作为当前节点新的前驱节点。
     * 返回 false，当前节点不必被阻塞
     */ 
    if (ws > 0) {
        
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        
        /**
         * 进入这个分支，说明前节点的等待状态既不是-1，也不是1。
         * 那么这个时候前节点的等待状态有可能为 0，-2，-3。官方给出的答案是只有可能为 0 或 -3。
         * 为什么没有可能为 -2 呢？这个是只用于等待队列的。
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

private final boolean parkAndCheckInterrupt() {
    // 阻塞当前线程
    LockSupport.park(this);
    // 返回当前线程的中断状态，并且清除其中断状态
    return Thread.interrupted();
}

public final boolean release(int arg) {
    if (tryRelease(arg)) { // 尝试释放同步状态成功
        // 获取head指向的节点
        Node h = head;
        if (h != null && h.waitStatus != 0)
            // 唤醒head的后继节点
            unparkSuccessor(h);
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    
    // 获取当前节点的等待状态
    int ws = node.waitStatus;
    
    if (ws < 0)
        // 尝试将节点的等待状态设置成0
        compareAndSetWaitStatus(node, ws, 0);

    // 获取下一个节点
    Node s = node.next;

    // 下面这个 if 分支主要就是检查后继节点是否还在同步队列中，如果不在就在同步队列中找个合适的节点
    // 如果后继节点为 null 或者被取消等待
    // 那么就顺着同步队列从后往前遍历，尝试找到一个不为null且等待状态小于等于0的节点
    // 如果找到，那么将这个节点作为head的后继节点
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }

    // 如果 head 的后继节点不为 null，就将其从阻塞状态中唤醒。
    if (s != null)
        LockSupport.unpark(s.thread);
}

public final void acquireShared(int arg) {
    // 若tryAcquireShared 返回大于等于0，说明成功获取同步状态
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

private void doAcquireShared(int arg) {
    // 为当前线程生成节点（其模式为共享式），并将该节点添加到同步队列中。
    final Node node = addWaiter(Node.SHARED);

    // 获取同步状态的标志，默认为 false。
    boolean failed = true;
    try {

        // 当前线程的中断状态，默认为 false。
        boolean interrupted = false;

        // 开始无限循环，尝试让当前线程获取同步状态。
        for (;;) {
            
            // 获取当前节点的前驱节点
            //用 final 来修饰这个前驱节点就是为了避免这个前驱节点在并发的时候被其他线程改变
            final Node p = node.predecessor();
            
            // 只有前驱节点为 head 的时候（和独占式一样），才会去尝试获取同步状态
            if (p == head) {

                // tryAcquireShared 返回的是还剩余可以共享的资源个数
                int r = tryAcquireShared(arg);

                if (r >= 0) {// 说明还有资源或者资源刚好用完
                    // 后面会介绍这个方法，现在只需知道这个方法是用来将 node 设置为头节点 head，并且尝试唤醒其后继节点
                    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);
    }
}

/**
 * @param pred，前驱节点
 * @param node，当前节点
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // ws，前驱节点的等待状态
    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.
         * 前驱节点的等待状态已经被设置成 SIGNAL，当前节点可以安全地阻塞住。
         */
        return true;
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         * 前驱节点已经被取消。从后往前遍历整个同步队列，直到找到一个还未被取消的节点
         * 将其设置成当前节点的前驱节点
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * 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.
         * 现在这里应该能够看得懂为什么这里可能会有 PROPAGATE 的可能了吧
         * 0 是独占式节点的初始值，PROPAGATE 是共享式节点的初始值
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

/**
 * @param node，当前节点
 * @param propagate，剩余可用共享资源个数
 */
private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    // 将当前节点设置为头节点
    setHead(node);
    // 根据propagate的值和其后继节点的是否为shared来决定是否尝试去唤醒其后继节点
    if (propagate > 0 || h == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

private void doReleaseShared() {
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                // 进入这个分支，说明 head 后面已经有节点加入
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;// head节点状态被改变，重新检查head的等待状态
                // CAS 成功将head节点的等待状态设置成0之后，会去尝试唤醒其后继节点
                unparkSuccessor(h);
            }

            // 代码执行到这里，说明此时同步队列中只有一个节点，即 head == tail，
            // 且这个节点的等待状态为 0（初始状态）
            else if (ws == 0 &&
                        !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                // CAS 失败，说明有其他节点加入到同步队列中，
                // 从而触发了当前节点的等待状态发生变化，需要重新循环检查
                continue;// loop on failed CAS
        }
        if (h == head)// 如果 head 改变了，就继续循环
            break;
    }
}

/**
 * @param node，头节点 head
 */
private void unparkSuccessor(Node node) {
    
    // 获取头节点的等待状态
    int ws = node.waitStatus;

    // 通过 CAS 将 head 节点的等待状态更新成 0。
    // 在并发环境下，这个 CAS 可能会失败，不过没有什么影响
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    // 获取下一个节点
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        // 后继节点被取消，从后往前遍历同步队列直到找到合适的后继节点
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        // 唤醒后继节点对应的线程
        LockSupport.unpark(s.thread);
}

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        // 修改head节点的等待状态，并尝试唤醒后继节点
        doReleaseShared();
        return true;
    }
    return false;
}