ReentrantLock核心源码分析，AQS独占模式，可重入锁

Posted 2021-09-13 可持续化发展

看前须知

        由于笔记比较多，看的时候，建议把代码copy到VS code 或者IDEA 中查看（为了可以点击方法进行跳转，方便阅读）。主要看方法上面的注释。本篇文章的图片来源于小刘老师的源码培训班。哔哩哔哩搜素：小刘讲源码。本篇文章仅用于作者本人复习源码知识点。

我的笔记

public class ReentrantLock implements Lock, java.io.Serializable {
    //默认使用非公平锁
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    //sync 在运行时要么是 FairSync 子类，要么是 NonfairSync 子类
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    //ReentrantLock.lock时，会调用相应sync 子类的 lock方法
    public void lock() {
        sync.lock();//这个是不响应中断的lock
    }
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);//响应中断的lock，这个lock 会用到cancelAcquire方法
    }
    
    public void unlock() {
        sync.release(1);
    }
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;

    abstract static class Sync extends AbstractQueuedSynchronizer {
        abstract void lock();       

    }

    /**
    学习ReentrantLock 前，须知
    本笔记中带有//......的地方是指在ReentrantLock 这个可重入的独占锁中没有用到的代码，就不贴出来了。
    为了方便阅读，我把一些方法移动了位置，注意看方法的注释。它表明了这个方法的所属类。

    ReentrantLock 公平锁模式的lock方法，这个方法是不响应中断的。这里所谓的不响应中断指的是
    线程A被 park后，给它一个中断信号，它醒来后，如果A线程的节点不是head的第一个后继 或 锁还没有被释放，
        A线程会在acquireQueued中经过自旋，又会被park。
    
    公平锁加锁的调用链如下：
    ReentrantLock.lock -> FairSync.lock ->AQS.acquire -> FairSync.tryAcquire        
        -> AQS.addWaiter -> AQS.acquireQueued -> AQS.shouldParkAfterFailedAcquire
        -> AQS.parkAndCheckInterrupt -> 返回AQS.acquire方法中调用selfInterrupt，再次给当前线程一个中断信号
        -> 最后返回 业务层逻辑了。
    先讲解的是FairSync。
    

    AQS的等待者队列(head.next -> tail)【双向队列的节点看 waitStatus、thread】、 exclusiveOwnerThread、AQS.state

    先对在ReentrantLock的公平锁中的AQS等待者队列的基本情况进行介绍：
    这个队列是FIFO的、延迟初始化的双向队列。为什么要双向？因为它有那种操作需求：获取当前节点的前置节点，需要判断当前节点是不是head节点的第一个后继节点。
    因为当前节点如果是head.next节点，才有权利去争夺锁tryAcquire.
        延迟初始化是指第一个线程来的时候，直接获取锁成功，将AQS.state从0改为1，exclusiveOwnerThread设为当前线程。
    这时，没有生成队列的head节点。第二个线程来的时候，在AQS.enq()方法中会为第一个线程补上一个Node节点作为head。而这个Node对象是空的构造方法。
    head的意义是逻辑上代表当前独占锁的线程。head节点的thread 为null。waitStatus为-1.

    队列的入队（关注Node节点的waitStatus、thread、prev、next）
    head节点延迟加载。
    在入队的过程中，当前时刻最后插入的node节点a的waitStatus等于0。
        过一会再插入一个节点b的话，b会将a的waitStatus由0改为Node.SIGNAL（-1）。
        反正最后一个入队的节点.waitStatus等于0

    队列的出队，FIFO。新的head的thread设为null。

    取消排队
    AQS中有个cancelAcquire方法，取消排队的。看下文。

    唤醒的情况有2种：
    1.中断方式的唤醒，看看lock是否响应中断。
    如果响应中断，就向上抛出异常，调用cancelAcquire方法取消排队。
    如果不响应中断，有可能继续被park。
    2.调用ReentrantLock.unlock的方式去唤醒
     */    
    static final class FairSync extends Sync {
        //公平锁入口..
        //不响应中断的加锁..响应中断的 方法为：lockinterrupted。。
        final void lock() {
            acquire(1);
        }
        /**
         * AQS.acquire
         * 这个方法就是为了获取锁。如果获取失败就会入队，park。醒来后再尝试获取。最后看看要不要设置中断
         * 它会调用FairSync.tryAcquire、AQS.addWaiter、AQS.acquireQueued、AQS.selfInterrupt方法。
         * 我们一个一个分析。
         */
        public final void acquire(int arg) {
            //条件一：!tryAcquire 尝试获取锁 获取成功返回true  获取失败 返回false。
            //条件二：2.1：addWaiter 将当前线程封装成node入队
            //       2.2：acquireQueued 挂起当前线程   唤醒后相关的逻辑..
            //      acquireQueued 返回true 表示挂起过程中线程被中断唤醒过..  false 表示未被中断过..
            if (!tryAcquire(arg) &&
                    acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                //再次设置中断标记位 true
                //lock方法完了以后，回到业务层面了。如果业务层面的代码是响应中断的话，就会去处理一些中断逻辑
                //如果不响应中断的话，就什么也不会发生。
                selfInterrupt();
        }
        /**
         * tryAcquire方法的返回值意义是
         * 尝试获取锁
         * 抢占成功：返回true  包含重入..
         * 抢占失败：返回false
         * 
         * 大体逻辑是：
         * 1.获取AQS的state
         * 2.如果state等于0，说明当前AQS处于无锁状态，就会去检查
         *      队列中除了head节点，在当前线程前面是否有等待者线程。
         *   2.1.如果没有等待者线程，当前线程就会通过CAS的方式将AQS.state从0改为1，
         *          并将ExclusiveOwnerThread设为当前线程，return true;
         * 
         *   2.2.如果当前线程前面有等待者线程，就返回false，获取锁失败，要入队，被挂起。
         * 3.如果AQS.state不等于0，就会再去判断 当前线程是不是独占锁线程。如果是的话，就会走重入锁的逻辑。return true;
         * 4.如果尝试获取锁失败了。return false;
         *     可能原因：
         *     (1)CAS竞争失败了。
         *     (2)当前线程不是独占锁线程，独占锁线程还没有释放锁。AQS.state大于0
         */
        protected final boolean tryAcquire(int acquires) {
            //current 当前线程
            final Thread current = Thread.currentThread();
            //AQS state 值
            int c = getState();
            //条件成立：c == 0 表示当前AQS处于无锁状态..
            if (c == 0) {
                //条件一：
                //因为fairSync是公平锁，任何时候都需要检查一下 队列中在当前线程之前是否有等待者..
                //hasQueuedPredecessors() 方法返回 true 表示当前线程前面有等待者，当前线程需要入队等待
                //hasQueuedPredecessors() 方法返回 false 表示当前线程前面无等待者，直接尝试获取锁..
                //条件二：compareAndSetState(0, acquires)
                //成功：说明当前线程抢占锁成功
                //失败：说明存在竞争，且当前线程竞争失败..
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    //成功之后需要做什么？
                    //设置当前线程为 独占者 线程。
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //执行到这里，有几种情况？
            //c != 0 大于0 的情况，这种情况就需要检查一下 当前线程是不是 独占锁的线程，因为ReentrantLock是可以重入的.
            //条件成立：说明当前线程就是独占锁线程..
            else if (current == getExclusiveOwnerThread()) {
                //锁重入的逻辑..
                //nextc 更新值..
                int nextc = c + acquires;
                //越界判断，当重入的深度很深时，会导致 nextc < 0 ，int值达到最大之后 再 + 1 ...变负数..
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                //更新的操作
                setState(nextc);
                return true;
            }
            //执行到这里？
            //1.CAS失败  c == 0 时，CAS修改 state 时 未抢过其他线程...
            //2.c > 0 且 ownerThread != currentThread.
            return false;
        }
        /**AQS.hasQueuedPredecessors */
        public final boolean hasQueuedPredecessors() {            
            Node t = tail; 
            Node h = head;
            Node s;
            return h != t &&
                ((s = h.next) == null || s.thread != Thread.currentThread());
        }

        /**
         * AQS.addWaiter里面有入队逻辑
         * 最终返回一个封装了当前线程的node，这个node此时是已经入队了的。
         * addWaiter的大体逻辑：
         * 1.利用当前线程封装一个node对象。
         * 2.如果队列中已经有节点了，则快速入队，
         *      2.1.当前节点prev指向tail；
         *      2.2.通过CAS的方式去移动tail引用，tail指向当前节点
         *      2.3.CAS成功后，将老的tail.next指向当前节点。return 封装了当前线程的node对象。
         * 3.如果当前队列为空 或者 CAS竞争入队失败了，就调用AQS.enq方法，进行完整入队操作。
         *      AQS.enq方法会保证封装了当前线程的node节点一定入队。
         */
        private Node addWaiter(Node mode) {
            //Node.EXCLUSIVE
            //构建Node ，把当前线程封装到对象node中了
            Node node = new Node(Thread.currentThread(), mode);
            //快速入队
            //获取队尾节点 保存到pred变量中
            Node pred = tail;
            //条件成立：队列中已经有node了
            if (pred != null) {
                 //当前节点的prev 指向 pred
                 node.prev = pred;
                 //cas成功，说明node入队成功
                 if (compareAndSetTail(pred, node)) {
                     //前置节点指向当前node，完成 双向绑定。
                     pred.next = node;
                     return node;
                 }
            }
            //什么时候会执行到这里呢？
            //1.当前队列是空队列  tail == null
            //2.CAS竞争入队失败..会来到这里..
            //完整入队..
            enq(node);
            return node;

        }
        /**
         * AQS.enq()
         * 返回值：返回当前节点的 前置节点。
         * enq方法保证当前线程封装的node 一定会加入到队列里面        
         * 大体逻辑：
         * 1.如果当前队列是空队列，作为当前持锁线程的 第一个后继线程，需要为当前持锁线程补一个node节点作为head。
         *      因为这个队列是延迟初始化的。补完head节点后，就自旋入队
         *      （当前节点prev指向tail，用CAS来移动tail，tail指向当前节点，老的tail.next指向当前节点）。
         *      如果CAS成功，就说明入队成功，构建好双向连接后，就return 当前节点的 前置节点。如果CAS竞争失败，就继续自旋。
         * 2.如果当前队列不是空队列，就通过CAS的方式，尝试入队。CAS成功，就入队了。失败，则继续自旋，去尝试入队。
         * 一定会入队成功。
         */
        private Node enq(final Node node) {
            //自旋入队，只有当前node入队成功后，才会跳出循环。
            for (;;) {
                Node t = tail;
                //1.当前队列是空队列  tail == null
                //说明当前 锁被占用，且当前线程 有可能是第一个获取锁失败的线程（当前时刻可能存在一批获取锁失败的线程...）
                if (t == null) { // Must initialize
                    //作为当前持锁线程的 第一个 后继线程，需要做什么事？
                    //1.因为当前持锁的线程，它获取锁时，直接tryAcquire成功了，没有向 阻塞队列 中添加任何node，所以作为后继需要为它擦屁股..
                    //2.为自己追加node，在自己前面补一个node节点作为head

                    //CAS成功，说明当前线程 成为head.next节点。
                    //线程需要为当前持锁的线程 创建head。
                    if (compareAndSetHead(new Node()))
                        tail = head;
                    //注意：这里没有return,会继续for。。
                }else {
                    //普通入队方式，只不过在for中，会保证一定入队成功！
                    node.prev = t;
                    if (compareAndSetTail(t, node)) {
                        t.next = node;
                        return t;
                    }
                }
            }
        }
        /**
         * AQS.acquireQueued方法需要 park当前节点的线程  和 唤醒后的逻辑。竞争资源
         * 返回值的意义：
         * true -> 表示当前线程在挂起的时候，被中断唤醒过
         * false ->表示当前线程在挂起的时候，未被中断过
         * 形参 node -> 已经入队的封装了当前线程的node对象
         * 形参 arg -> 这个arg一般是1 。是当前线程尝试获取锁时，通过CAS的方式修改state时用的，从0改为1。
         * 大体逻辑是
         * 1.开一个for自旋，获取当前节点的前置节点。
         * 2.如果 (前置节点是head && tryAcquire尝试获取锁成功了)，就做老head的出队操作
         *      2.1.将自己设为head。node.thread设为null，node.prev设为null。
         *      2.2.把老的head.next设为null，帮他 GC
         *      2.3.返回 interrupted。是否被中断过的布尔标记。
         * 3.如果 当前节点不是head.next节点 || tryAcquire尝试获取锁失败了，就  （head.next被唤醒后才有资格去抢锁tryAcquire）
         *      3.1.调用 shouldParkAfterFailedAcquire方法，判断一下是否需要park 当前线程。
         *          shouldParkAfterFailedAcquire方法要么true，要么false
         *              true -> 表示前置节点的waitStatus为SIGNAL(-1)，当前线程需要被挂起。
         *              false -> 有2种情况：
         *                  情况1：前置节点的waitStatus大于0，前置节点处于取消状态。
         *                  这个方法会将处于取消状态的node节点出队，给当前节点找一个 waitStatus小于等于0 的前置节点pred。构建双向连接
         *                  node.prev = pred;  pred.next = node;
         *                  情况2：前置节点的waitStatus等于0。就是插入队尾的情况。
         *                  这个方法会将前置节点的waitStatus设为-1。表示前置节点释放锁之后需要 喊醒我
         *      3.2.如果shouldParkAfterFailedAcquire返回true，就调用LockSupport.park(this); 挂起当前线程
         *      3.3.如果shouldParkAfterFailedAcquire返回false，就自旋。
         * 当前线程被挂起后，
         * 如果unpark 唤醒的，就会做自旋操作。
         * 如果是被其他线程唤醒的，就会将interrupted设为true，再做自旋操作。但公平锁的lock方法是不响应中断的，自旋后，大概率会被再次挂起。
         * 公平锁的lockInterruptibly方法会响应中断。线程被挂起后，中断唤醒，会抛出异常，调用cancelAcquire方法做出队操作。
         */
        final boolean acquireQueued(final Node node, int arg) {
            //true 表示当前线程抢占锁成功，普通情况下【lock】 当前线程早晚会拿到锁..
            //false 表示失败，需要执行出队的逻辑... （回头讲 响应中断的lock方法时再讲。）
            boolean failed = true;
            try {
                //当前线程是否被中断过
                boolean interrupted = false;
                //自旋..
                for (;;) {
                    //什么时候会执行这里？
                    //1.进入for循环时 在线程尚未park前会执行
                    //2.线程park之后 被唤醒后，也会执行这里...
                    //获取当前节点的前置节点..
                    final Node p = node.predecessor();
                    //条件一成立：p == head  说明当前节点为head.next节点，head.next节点在任何时候 都有权利去争夺锁.
                    //条件二：tryAcquire(arg)
                    //成立：说明head对应的线程 已经释放锁了，head.next节点对应的线程，正好获取到锁了..
                    //不成立：说明head对应的线程  还没释放锁呢...head.next仍然需要被park。。
                    if (p == head && tryAcquire(arg)) {
                        //拿到锁之后需要做什么？
                        //设置自己为head节点。
                        setHead(node);
                        //将上个线程对应的node的next引用置为null。协助老的head出队..
                        p.next = null; // help GC
                        //当前线程 获取锁 过程中..没有异常
                        failed = false;
                        //返回当前线程的中断标记..
                        return interrupted;
                    }
                    //shouldParkAfterFailedAcquire  这个方法是干嘛的？ 当前线程获取锁资源失败后，是否需要挂起呢？
                    //返回值：true -> 当前线程需要 挂起    false -> 不需要..
                    //parkAndCheckInterrupt()  这个方法什么作用？ 挂起当前线程，并且唤醒之后 返回 当前线程的 中断标记
                    // （唤醒：1.正常唤醒 其它线程 unpark 2.其它线程给当前挂起的线程 一个中断信号..）
                    if (shouldParkAfterFailedAcquire(p, node) &&
                            parkAndCheckInterrupt())
                        //interrupted == true 表示当前node对应的线程是被 中断信号唤醒的...
                        interrupted = true;
                }
            }finally {//lock()方法调用时，这块逻辑基本用不到。
                if (failed)
                    cancelAcquire(node);
            }
        }
    }
    /**
     * 到这里为止，ReentrantLock的公平锁的加锁过程就完了。
     * 下面说 公平锁的解锁过程。
     * 公平锁解锁的调用链是：
     * ReentrantLock.unlock -> AQS.release -> 
     * sync.tryRelease -> AQS.unparkSuccessor -> AQS.acquireQueued
     * 
     * release的大体逻辑为
     * 1.调用tryRelease方法去释放锁，如果当前线程完全释放锁了，就return true。如果未完全释放锁，则return false。因为有重入锁的逻辑。
     *      如果未完全释放锁，这个方法就直接返回了。
     * 2.如果当前线程完全释放锁了，则会调用unparkSuccessor方法去做唤醒操作。
     *      如果当前节点是最后一个节点了（waitStatus=0），则不用做唤醒操作，直接返回true。
     */
    public final boolean release(int arg) {
        //尝试释放锁，tryRelease 返回true 表示当前线程已经完全释放锁
        //返回false，说明当前线程尚未完全释放锁..
        if (tryRelease(arg)) {
            //head什么情况下会被创建出来？
            //当持锁线程未释放线程时，且持锁期间 有其它线程想要获取锁时，其它线程发现获取不了锁，而且队列是空队列，此时后续线程会为当前持锁中的
            //线程 构建出来一个head节点，然后后续线程  会追加到 head 节点后面。
            Node h = head;
            //条件一:成立，说明队列中的head节点已经初始化过了，ReentrantLock 在使用期间 发生过 多线程竞争了...
            //条件二：条件成立，说明当前head后面一定插入过node节点。
            //h.waitStatus != 0这一步主要是为了 最后一个node节点释放锁的逻辑，
            //   最后一个节点 head、tail都指向它，waitstatus=0，就不用再唤醒后面的节点了。因为后面没有节点嘛
            if (h != null && h.waitStatus != 0)
                //唤醒后继节点..
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
    
    /**
     * Sync.tryRelease() 尝试去释放锁
     * tryRelease的大体逻辑：
     * 1.将当前AQS.state 减1
     * 2.如果state等于0，说明当前线程完全释放锁了。将exclusiveOwnerThread设为null。返回 true
     * 3.如果state不等于0，说明当前线程未完全释放锁。返回 false
     */
    protected final boolean tryRelease(int releases) {
        //减去释放的值..
        int c = getState() - releases;
        //条件成立：说明当前线程并未持锁..直接异常.,.
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        //当前线程持有锁..
        //是否已经完全释放锁..默认false
        boolean free = false;
        //条件成立：说明当前线程已经达到完全释放锁的条件。 c == 0
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        //更新AQS.state值
        setState(c);
        return free;
    }
    /**
     * AQS.unparkSuccessor 要唤醒后面的等待者线程。调用时机：释放锁的时候、取消排队的时候
     * unparkSuccessor的大体逻辑为：
     * 1.获取当前节点的waitStatus，获取当前节点.next节点，就是它的直接后继s。
     * 2.如果后继节点s 为空  || s.waitStatus 大于0（取消状态），则
     *      从后往前找，找一个位于当前节点后面的距离最近的 waitStatus小于等于0 的节点，将其封装的线程唤醒。
     *          如果找到了，就唤醒节点封装的线程 LockSupport.unpark对应的线程
     *          如果没找到，就返回了。
     * 3.如果后继节点s 不为空，则唤醒其封装的thread。LockSupport.unpark
     * 被唤醒的线程会从AQS.acquireQueued方法的parkAndCheckInterrupt处开始往下执行，自旋。
     * ......就是acquireQueued的逻辑了。 
     */
    private void unparkSuccessor(Node node) {
        //获取当前节点的状态
        int ws = node.waitStatus;
        if (ws < 0)//-1 Signal  改成零的原因：因为当前节点即将完成唤醒后继节点的任务了..
            compareAndSetWaitStatus(node, ws, 0);
        //s是当前节点 的第一个后继节点。
        Node s = node.next;
        //条件一：
        //s 什么时候等于null？
        //1.当前节点就是tail节点时  s == null。
        //2.当新节点入队未完成时（1.设置新节点的prev 指向pred  2.cas设置新节点为tail（已经算入队了）   3.（未完成）pred.next -> 新节点 ）
        //需要找到可以被唤醒的节点..
        //条件二：s.waitStatus > 0    前提：s ！= null
        //成立：说明 当前node节点的后继节点是 取消状态... 需要找一个合适的可以被唤醒的节点..
        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;
          //上面循环，会找到一个离当前node最近的一个可以被唤醒的node。 node 可能找不到  node 有可能是null、、
        }
        //如果找到合适的可以被唤醒的node，则唤醒.. 找不到 啥也不做。
        if (s != null)
            LockSupport.unpark(s.thread);
    }
    /**
     * 到这里为止，公平锁解锁的逻辑讲完了。下面说一下，ReentrantLock的公平锁中响应中断的lock
     * lockInterruptibly 响应中断的加锁逻辑，就是可以调用 AQS.cancelAcquire方法的。
     * 
     * 不要忘记sync的运行时状态是什么类。sync = fair ? new FairSync() : new NonfairSync();
     * 
     * 调用链是：
     * ReentrantLock.lockInterruptibly -> AQS.acquireInterruptibly -> FairSync.tryAcquire
     * -> AQS.doAcquireInterruptibly -> AQS.addWaiter 
     * -> shouldParkAfterFailedAcquire -> parkAndCheckInterrupt 
     * 前面和普通的公平锁 lock 差不多，区别在于：
     * 当前线程被中断唤醒后，会向上抛出一个异常，throw new InterruptedException();
     *     然后，走到finally块中，执行 cancelAcquire ，做取消排队的操作。
     * 响应中断的lock，才会做取消排队的操作。
     * 
     */
    /**
     * AQS.cancelAcquire方法用于
     * 取消指定node参与竞争。取消排队，出队。
     * cancelAcquire方法的大体逻辑：形参为要取消排队的node节点
     * 1.将node.thread设为null, node.waitStatus设为 1，cancelled状态
     * 2.找一个最近的 waitStatus小于等于0 的前驱节点 pred
     * 3.根据当前取消排队的node的位置不同，分情况：
     *  3.1.当前node是队尾  tail -> node
     *      通过CAS的方式将tail指向pred 节点，通过CAS的方式将pred.next改为null
     *  3.2.当前node 不是 head.next 节点，也不是 tail
     *      3.2.1.pred.waitStatus 等于-1，|| 等于0，等于0的时候，会用CAS再设为-1，保证pred.waitStatus等于-1后，
     *          就出队：pred.next -> node.next 节点后，当node.next节点 被唤醒后,
     *           调用 shouldParkAfterFailedAcquire 会让node.next 节点越过取消状态的节点
     *           完成真正出队操作。
     *      3.2.2.pred.waitStatus 等于 1，极端情况。
     *          这种情况的话，会调用unparkSuccessor方法去唤醒当前节点的后继节点，后继节点
     *          会调用shouldParkAfterFailedAcquire方法让取消状态的节点出队
     *  3.3.当前node 是 head.next节点。
     *      当前节点会调用unparkSuccessor方法唤醒后继节点。
     *      后继节点唤醒后，会调用 shouldParkAfterFailedAcquire方法，
     *      让node.next 节点越过取消状态的节点，并与 head 构建双向连接。
     *  4.最后 node.next = node; // help GC 让这个节点的next 指向自己
     */
    private void cancelAcquire(Node node) {
        //空判断..
        if (node == null)
            return;
        //因为已经取消排队了..所以node内部关联的当前线程，置为Null就好了。。
        node.thread = null;
        //获取当前取消排队node的前驱。
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;
        //拿到前驱的后继节点。
        //1.当前node
        //2.可能也是 ws > 0 的节点。
        Node predNext = pred.next;
        //将当前node状态设置为 取消状态  1
        node.waitStatus = Node.CANCELLED;
        /**
         * 当前取消排队的node所在 队列的位置不同，执行的出队策略是不一样的，一共分为三种情况：
         * 1.当前node是队尾  tail -> node
         * 2.当前node 不是 head.next 节点，也不是 tail
         * 3.当前node 是 head.next节点。
         */
        //条件一：node == tail  成立：当前node是队尾  tail -> node
        //条件二：compareAndSetTail(node, pred) 成功的话，说明修改tail完成。
        if (node == tail && compareAndSetTail(node, pred)) {
            //修改pred.next -> null. 完成node出队。
            compareAndSetNext(pred, predNext, null);
        } else {
            //保存节点 状态..
            int ws;
            //第二种情况：当前node 不是 head.next 节点，也不是 tail
            //条件一：pred != head 成立， 说明当前node 不是 head.next 节点，也不是 tail
            //条件二： ((ws = pred.waitStatus) == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL)))
            //条件2.1：(ws = pred.waitStatus) == Node.SIGNAL   成立：说明node的前驱状态是 Signal 状态   不成立：前驱状态可能是0 ，
            // 极端情况下：前驱也取消排队了..
            //条件2.2:(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))
            // 假设前驱状态是 <= 0 则设置前驱状态为 Signal状态..表示要唤醒后继节点。
            //if里面做的事情，就是让pred.next -> node.next  ,所以需要保证pred节点状态为 Signal状态。
            if (pred != head &&
                    ((ws = pred.waitStatus) == Node.SIGNAL ||
                            (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                    pred.thread != null) {
                //情况2：当前node 不是 head.next 节点，也不是 tail
                //出队：pred.next -> node.next 节点后，当node.next节点 被唤醒后
                //调用 shouldParkAfterFailedAcquire 会让node.next 节点越过取消状态的节点
                //完成真正出队。
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {
                //当前node 是 head.next节点。  更迷了...
                //类似情况2，后继节点唤醒后，会调用 shouldParkAfterFailedAcquire 会让node.next 节点越过取消状态的节点
                //队列的第三个节点 会 直接 与 head 建立 双重指向的关系：
                //head.next -> 第三个node  中间就是被出队的head.next 第三个node.prev -> head
                unparkSuccessor(node);
            }
            node.next = node; // help GC 让这个节点的指针指向自己
        }
    }
    /**
     * ReentrantLock的非公平锁 NonfairSync，
     * 非公平锁也有响应中断的lock（lock）和不响应中断的lock（lockInterruptibly）
     * 公平锁和非公平锁比较类似，它们的区别在于：
     * 非公平锁lock的时候，会直接尝试用CAS 的方式 将AQS.state 从0改为1，去抢锁。没有管阻塞队列中是否有等待者线程。
     * 如果拿到锁了，就直接将exclusiveOwnerThread设为当前线程。
     * 如果拿不到，会调用tryAcquire方法。
     * tryAcquire方法在state等于0的时候，也尝试用CAS的方式去抢锁（没有管阻塞队列中是否有等待者线程），还会尝试重入锁逻辑。
     * 如果还是拿不到，就入队，挂起，等待被唤醒。
     * 非公平锁的吞吐量比公平锁要稍微好一些。
     * 公平锁在加锁的时候会判断当前队列中是否有其他线程在等待。非公平锁不会判断。
     * 
     */
    static final class NonfairSync extends Sync {
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
    }


}

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
    static final class Node {       
        //枚举：独占模式
        static final Node EXCLUSIVE = null;
        //表示当前节点处于 取消 状态
        static final int CANCELLED =  1;
        /** waitStatus value to indicate successor's thread needs unparking */
        //注释：表示当前节点需要唤醒他的后继节点。（SIGNAL 表示其实是 后继节点的状态，需要当前节点去喊它...）
        static final int SIGNAL    = -1;
        //node状态，可选值（0 ， SIGNAl（-1）, CANCELLED（1）, CONDITION, PROPAGATE）
        // waitStatus == 0  默认状态
        // waitStatus > 0 取消状态（在ReentrantLock模式下）
        // waitStatus == -1 表示当前node如果是head节点时，释放锁之后，需要唤醒它的后继节点。
        volatile int waitStatus;

        //因为node需要构建成  fifo 队列， 所以 prev 指向 前继节点
        volatile Node prev;

        //因为node需要构建成  fifo 队列， 所以 next 指向 后继节点
        volatile Node next;

        //当前node封装的 线程本尊..
        volatile Thread thread;

        Node() {    // Used to establish initial head or SHARED marker
        }

        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

        
        //......
    }    
    
    //头结点 任何时刻 头结点对应的线程都是当前持锁线程。这个线程是活跃状态的
    private transient volatile Node head;
    //阻塞队列的尾节点   (阻塞队列不包含 头结点  head.next --->  tail 认为是阻塞队列)
    private transient volatile Node tail;
    //表示资源
    //独占模式：0 表示未加锁状态   >0 表示已经加锁状态
    private volatile int state;

    private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
    }
    /**
     * 就是给当前节点找一个好爸爸，给爸爸设为 -1
     * 总结：
     * 1.当前节点的前置节点是 取消状态 ，第一次来到这个方法时 会越过 取消状态的节点， 第二次 会返回true 然后park当前线程
     * 2.当前节点的前置节点状态是0，当前线程会设置前置节点的状态为 -1 ，第二次自旋来到这个方法时  会返回true 然后park当前线程.
     *
     * 参数一：pred 当前线程node的前置节点
     * 参数二：node 当前线程对应node
     * 返回值：boolean  true 表示当前线程需要挂起..
     */
    //AQS#
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        //获取前置节点的状态
        //waitStatus：0 默认状态 new Node() ； -1 Signal状态，表示当前节点释放锁之后会唤醒它的第一个后继节点； >0 表示当前节点是CANCELED状态
        int ws = pred.waitStatus;
        //条件成立：表示前置节点是个可以唤醒当前节点的节点，所以返回true ==> parkAndCheckInterrupt() park当前线程了..
        //普通情况下，第一次来到shouldPark。。。 ws 不会是 -1
        if (ws == Node.SIGNAL)
            return true;

        //条件成立： >0 表示前置节点是CANCELED状态
        if (ws > 0) {
            //找爸爸的过程，条件是什么呢？ 前置节点的 waitStatus <= 0 的情况。
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            //找到好爸爸后，退出循环
            //隐含着一种操作，CANCELED状态的节点会被出队。
            pred.next = node;

        } else {
            //当前node前置节点的状态就是 0 的这一种情况。
            //将当前线程node的前置node，状态强制设置为 SIGNAl，表示前置节点释放锁之后需要 喊醒我..
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
    //AQS#parkAndCheckInterrupt
    //park当前线程 将当前线程 挂起，唤醒后返回当前线程 是否为 中断信号 唤醒。
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }


    //......
}

public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
    //独占模式下表示当前持有锁的线程
    private transient Thread exclusiveOwnerThread;    

    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }
    //...... 
}

图片