03.JUC核心篇：AQS(AbstractQueueSynchronizer)

应付面试可直接跳转到文章结尾处的总结

AQS（AbstractQueueSynchronizer）

在锁框架中，AbstractQueueSynchronizer抽象类可以毫不夸张的说，占据着核心地位，它提供了一个基于FIFO队列，可以用于构建锁或者其他相关装置的基础框架。

AbstractQueueSynchronizer会把所有的请求线程构成一个CLH队列，当一个线程执行完毕（lock.unlock）时会激活自己的后继节点，但正在执行的线程并不在队列中，而那些等待执行的线程全部处于阻塞状态。

注：大多数JUC包下的并发工具类都是利用AbstractQueuedSynchronizer同步器来委托实现的，它是用来构建锁或者其他同步组件的基础框架。想要弄明白并发原理，搞明白AQS的实现机制很重要。

AQS主要实现了独占式和共享式

独占式：同步状态在0与1之间切换，同一时刻只有一个线程获取锁进行操作，其他线程挂起，ReentrantLock就是一个经典的独占式锁。

共享式：PROPAGATE的数值大于0，可以使同一时刻有多个线程获取锁，如果PROPAGATE小于0，则就变成了共享式模式，可以参照Semphore。

数据结构

AbstractQueuedSynchronizer类底层的数据结构使用的是 双向链表 + state(锁状态) + 底层CAS操作。

Sync queue（同步队列）：是一个双向链表，包括head节点和tail节点，head节点主要做后续的调度。

Condition queue（条件队列）：这不是必须的，它是一个单向链表，只有当使用Condition时，才会存在此单向链表。并且可能会有多个。

概念：

• AQS使用了一个int类型的state成员变量表示同步状态，通过Node类型的head和tail头尾节点所确定的FIFO队列来完成资源获取线程的排队工作。
• 当一个线程成功的获取了同步状态，其他线程将无法获取到同步状态，没有成功获取同步状态的线程会成为节点加入该队列的尾部，为保证线程安全，使用compareAndSetTail(Node expect, Node update)方法原子更新在尾部插入等待节点。
• 头节点是获取同步状态成功的节点，头节点的线程在释放同步状态时，将会唤醒后继节点，而后继节点将会在获取同步状态成功时将自己设置为首节点。
  • 获取同步状态成功的线程才能设置头节点，且只有一个线程能获取到同步状态，不存在线程安全问题，所以不用CAS来设置节点。

同步容器AQS的基本用法

同步器的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态，在抽象方法的实现过程中免不了要对同步状态进行更改，这时就需要使用同步器提供的三个方法getState()、setState(int newState)、compareAndSetState(int expect, int update) 来进行操作，因为它们能够保证状态的改变是安全的。

子类推荐被定义为自定义同步组件的静态内部类，同步器自身没有实现任何同步接口，它仅仅是定义了若干同步状态获取和释放的方法供自定义同步组件使用，同步器既可以支持独占式地获取同步状态，也可以支持共享式的获取同步状态，这样就可以方便实现不同类型的同步组件。

使用技巧

同步器的设计是基于模板方法的，也就是说，使用者需要继承同步器并重写指定的方法，随后将同步器组合在自定义同步组件的实现中，并调用同步器提供的模板方法，而这些模板方法将会调用使用者重写的方法。而重写同步器指定的方法时，需要使用同步器提供的如下三个方法来访问或修改同步状态。

• getState() ： 获取当前同步状态。
• setState(int newState) ： 设置当前同步状态。
• compareAndSetState(int expect, int update) ： 使用CAS设置当前状态，该方法能保证状态设置的原子性。

AQS可重写的方法

• boolean tryAcquire(int)：独占式获取同步状态，实现此方法需要查询当前状态并判断同步状态是否符合预期，然后再进行CAS设置同步状态。
• boolean tryRelease(int)：独占式释放同步状态，等待获取同步状态的线程将有机会获取同步状态。
• boolean isHeldExclusively()：当前同步器是否在独占模式下被线程占用，一般此方法表示是否被当前线程所独占。
• int tryAcquireShared(int)：共享式获取同步状态。
• boolean tryReleaseShared(int)：共享式释放同步状态。

AQS中的模板方法

以下的模板方法的内部都会调用上面说的5个可被重写的方法，而自定义同步组件在实现一些同步功能时一般会使用委托的方法调用AQS的这些模板方法，而不是直接调用上面AQS的那5个可重写的方法，当然也有例外，比如：ReentrantLock的tryLock()方法就是直接调用 boolean tryAcquire(int)

• void acquire(int)：独占式获取同步状态，如果当前线程获取同步状态成功，则由该方法返回，否则，将会进入同步队列等待，该方法将会调用重写的tryAcquire(int)方法。
• void acquireInterruptibly(int)：与acquire(int arg)相同，但是该方法响应中断，当前线程未获取到同步状态而进入同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException并返回。
• boolean tryAcquireNanos(int ,long)：在acquireInterruptibly(int arg)基础上增加了超时限制，如果当前线程在超时时间内没有获取到同步状态，那么将会返回false,如果获取到了返回true。
• boolean release(int)：独占式的释放同步状态，该方法会在释放同步状态之后，将同步队列中第一个节点包含的线程唤醒。
• void acquireShared(int)：共享式的获取同步状态，如果当前线程未获取到同步状态，将会进入同步队列等待，与独占式获取的主要区别是在同一时刻可以由多个线程获取到同步状态。
• void acquireSharedInterruptibly(int)：与acquireShared(int)相同，该方法响应中断。
• boolean tryAcquireSharedNanos(int, long)：在acquireSharedInterruptibly(int)基础上增加了超时限制。
• boolean releaseShared(int)：共享式的释放同步状态。

源码示例

AQS类中的排他锁示例

class Mutex implements Lock, java.io.Serializable {
    /**
     * 如果state是0，表明锁没有被其他线程抢占，可以获取锁
     * 如果state是1，表明锁被某个线程抢占了
     */
    private static class Sync extends AbstractQueuedSynchronizer {
        // 锁的状态，即是否被某个抢占了
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        // 如果state是0，尝试抢锁
        public boolean tryAcquire(int acquires) {
            assert acquires == 1; // Otherwise unused
            
            // cas原子操作地修改state的值，修改成功，表示抢锁成功
            if (compareAndSetState(0, 1)) {
               	// 将当前线程设置为独占所有者线程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        // 将state重置为0（释放锁）
        protected boolean tryRelease(int releases) {
            assert releases == 1; // Otherwise unused
            // 如果state为0，表明没有线程获取到锁，那么就不存在释放锁这种说法，所以管程状态错误
            if (getState() == 0) throw new IllegalMonitorStateException();
            // 独占锁的释放，就是独占线程释放锁,所以独占所有者线程设为空
            setExclusiveOwnerThread(null);
            /*
             * 释放锁，表明之前锁已经被获取了，当前只会一个线程能够调用setState()，
             * 所以可以不用compareAndSetState(int,int）方法来进行原子操作的更新，可以直接调用setState()方法
             */
            setState(0);
            return true;
        }

        Condition newCondition() {
            return new ConditionObject();
        }

        private void readObject(ObjectInputStream s)
                throws IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

    // The sync object does all the hard work. We just forward to it.
    private final Sync sync = new Sync();

    // lock接口的实现全部委托给sync
    public void lock() {
        sync.acquire(1);
    }

    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    public void unlock() {
        sync.release(1);
    }

    public Condition newCondition() {
        return sync.newCondition();
    }

    public boolean isLocked() {
        return sync.isHeldExclusively();
    }

    public boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
}

AQS类中的共享锁示例

class BooleanLatch {

    private static class Sync extends AbstractQueuedSynchronizer {

        boolean isSignalled() {
            return getState() != 0;
        }

        protected int tryAcquireShared(int ignore) {
            return isSignalled() ? 1 : -1;
        }

        protected boolean tryReleaseShared(int ignore) {
            setState(1);
            return true;
        }
    }

    private final Sync sync = new Sync();

    public boolean isSignalled() {
        return sync.isSignalled();
    }

    public void signal() {
        sync.releaseShared(1);
    }

    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
}

AQS源码分析

类继承关系

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

AbstractOwnableSynchronizer抽象类源码

public abstract class AbstractOwnableSynchronizer
    implements java.io.Serializable {

    // 版本序列号
    private static final long serialVersionUID = 3737899427754241961L;

    // 构造函数
    protected AbstractOwnableSynchronizer() { }

   	// 当前持有独占锁的线程
    private transient Thread exclusiveOwnerThread;

    // 设置独占线程
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    // 获取独占线程
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

这个类中只有一个Thread类型的变量exclusiveOwnerThread及getter/setter方法，用来获取/设置独占线程，正如其名Ownable 一个线程可能专有的同步器。

这对getter/setter方法对于独占锁类型的并发工具特别有用。如ReentrantLock是一个可重入排他锁（排他锁又称独占锁），因此ReentrantLock类中经常用到这两个方法。

类属性

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer {
    // 头节点
    private transient volatile Node head;

    // 阻塞的尾节点，每个新的节点进来，都插入到最后，也就是形成一个链表
    private transient volatile Node tail;

    // 代表当前锁的状态
    // = 0: 表示没有被占用
    // > 0: 代表有线程持有当前锁，这个值也可能会大于1，是因为锁可用重入，每次重入都加1
    private volatile int state;
}

内部类：Node

static final class Node {
    // 表示在同步队列中当前节点的下一个等待节点的类型常量：共享型
    static final Node SHARED = new Node();
    // 表示在同步队列中当前节点的下一个等待节点的类型常量：独占型
    static final Node EXCLUSIVE = null;
  
  	// 一下四个常量可以作为waitStatus属性值。
	  // 线程的等待状态：表示线程已经被取消
    static final int CANCELLED =  1;
  	// 线程的等待状态：表示后继线程需要被唤醒
    static final int SIGNAL    = -1;
  	// 线程的等待状态：表示线程在Condition上
    static final int CONDITION = -2;
  	// 表示下一个acquireShared需要无条件的传播
    static final int PROPAGATE = -3;

  	/**
  	 * CANCELLED：一个节点由于超时或者中断需要在CLH队列中取消等待状态，被取消的节点不会再次等待（节点进入此状态后不再变化）
  	 * SIGNAL：当前节点的后继节点处于等待状态时，如果当前节点的同步状态被释放或者取消，必须唤起它的后继节点
  	 * CONDITION：当前节点在等待队列中，只有当节点的状态设置为0的时候该节点才会被转移到同步队列
  	 * PROPAGATE：下一次的共享模式同步状态的获取将会无条件的传播
  	 * 
  	 * 该属性初始的时候为0
  	 * 使用CAS来修改节点的状态
  	 * AQS 在状态判断时，用waitStatus > 0表示取消状态，waitStatus <=0 表示有效状态
  	 */
    volatile int waitStatus;

   	/**
   	 * 当前节点的前驱节点
   	 * 
   	 * 当前线程依赖它来检查waitStatus，在入队的时候才被分配，并且只有在出队的时候才被取消（为了GC），
   	 * 一个节点成为头节点仅仅是成功获取到锁的结果，一个被取消的线程永远也不会获取到锁，
   	 * 线程只取消自身，而不涉及其他节点
   	 */
    volatile Node prev;

   	/**
   	 * 当前节点的后继节点
   	 * 
   	 * 当前线程释放的时候才被唤起,在入队时分配,在绕过被取消的前驱节点时调整,在出队列的时候取消(为了GC)
   	 * 如果一个节点的next为空,我们可以从尾部扫描它的prev,双重检查。
   	 * 被取消节点的next设置为指向节点本身而不是null,为了isOnSyncQueue更容易操作
   	 */
    volatile Node next;

    // 节点所对应的线程
    volatile Thread thread;

    /**
     * 下一个等待者
     * 
     * 链接到下一个节点的等待条件，或特殊的值SHARED，因为条件队列只有在独占模式时才能被访问，
     * 所以我们只需要一个简单的连接队列在等待的时候保存节点，然后把他们转移到队列中重新获取
     * 因为条件只能是独占性的，我们通过使用特殊的值来表示共享模式
     *
     * nextWaiter在描述AQS同步队列的head、tail两个成员变量中不起太大的作用，只是表示共享型或独占型节点。
     * nextWaiter属性主要在描述Condition条件队列的firstWaiter和lastWaiter两个成员变量中起重要作用，表示下一个等待条件的节点
     */
    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;
    }
		
 	  // 用来建立初始化的head 或 SHARED的标记
    Node() {    
    }
  	// addWaiter方法使用
    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;
    }
}

内部类：ConditionObject

public class ConditionObject implements Condition, java.io.Serializable {
    private static final long serialVersionUID = 1173984872572414699L;
    // condition队列的头节点
    private transient Node firstWaiter;
    // condition队列的尾节点
    private transient Node lastWaiter;

    public ConditionObject() { }

   	// 添加新的waiter到wait队列
    private Node addConditionWaiter() {
      	// 保存尾节点
        Node t = lastWaiter;
      	// 尾节点不为空，并且尾节点的状态不为CONDITION
        if (t != null && t.waitStatus != Node.CONDITION) {
          	// 清除状态为CONDITION的节点
            unlinkCancelledWaiters();
          	// 将最后一个节点重新赋值给t
            t = 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;
    }

    private void doSignal(Node first) {
        do {
          	// 该节点的nextWaiter为空
            if ( (firstWaiter = first.nextWaiter) == null)
              	// 设置尾节点为空
                lastWaiter = null;
          	// 设置first节点的nextWaiter域
            first.nextWaiter = null;
        // 将节点从conditioin队列转移到sync队列失败并且condition队列中的头节点不为空，一直循环
        } while (!transferForSignal(first) &&
                 (first = firstWaiter) != null);
    }

  	// 唤醒first节点之后的所有节点
    private void doSignalAll(Node first) {
        // condition队列的头节点尾节点都设置为空
        lastWaiter = firstWaiter = null;
        do {
          	// 获取first节点的nextWaiter域节点
            Node next = first.nextWaiter;
          	// 设置first节点的nextWaiter域为空
            first.nextWaiter = null;
          	// 将first节点从conditioin队列转移到sync队列
            transferForSignal(first);
            // 重新设置next
            first = next;
        } while (first != null);
    }

  	// 从condition队列中清除状态为CANCEL的节点
    private void unlinkCancelledWaiters() {
      	// 保存condition队列头节点
        Node t = firstWaiter;
        Node trail = null;
        while (t != null) {
          	// 获取下一个节点
            Node next = t.nextWaiter;
            if (t.waitStatus != Node.CONDITION) {
              	// 设置t节点的nextWaiter域为null
                t.nextWaiter = null;
                if (trail == null)
                  	// 重新设置condition队列的头节点
                    firstWaiter = next;
                else
                  	// 设置trail节点的nextWaiter域为next节点
                    trail.nextWaiter = next;
                if (next == null)
                  	// 设置condition队列的尾节点
                    lastWaiter = trail;
            }
            else // t节点的状态为CONDITION状态
              	// 设置trail节点
                trail = t;
            t = next;
        }
    }

    // 唤醒一个等待线程。如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从await返回之前，该线程必须重新获取锁
    public final void signal() {
      	// 不被当前线程独占，抛出异常
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
      	// 保存condition队列头节点
        Node first = firstWaiter;
      	// 头节点不为空则唤醒一个等待线程
        if (first != null)
            doSignal(first);
    }

    // 唤醒所有等待线程。如果所有的线程都在等待此条件，则唤醒所有线程。在await返回之前，每个线程都必须重新获取锁。
    public final void signalAll() {
      	// 不被当前线程占用，抛出异常
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
      	// 头节点不为空则唤醒所有等待线程
        if (first != null)
            doSignalAll(first);
    }

   	// 等待，当前线程在接到信号之前一直处于等待状态，不响应中断
    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();
    }

   	// 等待，当前线程在接到信号或被中断之前一直处于等待状态
    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 cancelled
            unlinkCancelledWaiters();
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
    }

    // 等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态
    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();
    }

    // 等待，当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态
    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;
    }

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

独占式：acquire

逐行分析看着比较吃力，可以先看看最后的总结：AQS独占式获取锁逻辑：详细版

// 以独占模式获取（资源），忽略中断，即线程在aquire过程中，中断此线程是无效的
public final void acquire(int arg) {
  	// 调用tryAcquire方法获取同步状态
    if (!tryAcquire(arg) &&
        // 调用addWaiter方法把线程封装成一个Node节点添加到同步队列的尾部，
        // 然后调用acquireQueued方法使节点以自旋的方式获取同步状态
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

说明：通过调用acquire获取同步状态，该方法忽略中断，线程获取同步状态失败后，进入同步队列，在对其进行中断操作后，线程不会从同步队列移除。

流程：

• 首先调用 tryAcquire 方法获取同步状态，AQS并没有实现这个方法，具体的实现由它的继承类进行重写，如：ReentrantLock的Sync类。
• 如果获取同步状态成功直接返回true，如果获取失败执行下面的步骤。
• 调用addWaiter方法把线程封装成一个独占式的Node节点添加到同步队列的尾部，然后调用acquireQueued方法使节点以自旋的方式获取同步状态，如果获取同步状态失败，要挂起线程（被挂起的线程的唤醒主要依靠前驱节点的出队或阻塞线程被中断来实现），最后，线程如果在获取同步状态中和同步队列中被中断过，要进行自我中断。

添加新的等待节点：addwaiter

主要通过调用compareAndSetTail(Node node) 来确保正确安全的设置尾节点，避免了非线程安全状态下添加新节点时节点先后顺序混乱的情况，如果一次CAS设置尾节点失败，则直接进入enq(final Node) 方法通过自旋的CAS操作，直到将节点设置为尾节点成功。

// 把Node节点添加到同步队列的尾部
private Node addWaiter(Node mode) {
  	// 以独占模式把当前线程封装成一个Node节点
    Node node = new Node(Thread.currentThread(), mode);
    // 尝试快速入队
    Node pred = tail; // 当前队列的尾节点赋给pred
  	// 尾节点不为空
    if (pred != null) {
      	// 把旧的尾节点作为新节点的前驱节点
        node.prev = pred;
      	// 利用CAS把node作为尾节点
        if (compareAndSetTail(pred, node)) {
          	// 将新的node节点作为旧的尾节点的后继节点。 pred <-> node
            pred.next = node;
          	// 直接返回node
            return node;
        }
    }
  	// 尾节点为空 或者 利用CAS把node设置为尾节点失败
    enq(node);
    return node;
}

总结：简单来说就是把当前线程按照mode模式（独占/共享）封装成一个node节点，然后把node节点添加到队列尾部，但是当入队失败或者尾节点为空，就需要调用enq方法自旋了。

这里的操作非常经典，将入队操作提前尝试快速入队，如果失败才去执行自旋。

自旋添加尾节点：enq

// 采用自旋方式把node插入到队列中  t <-> node : t.next = node; node.prev = t;
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
      	// 如果尾节点为空，说明队列为空，必须初始化
        if (t == null) { // Must initialize
          	// 新建一个节点利用CAS设置为头节点
            if (compareAndSetHead(new Node()))
              	// tail 和 head都指向这个新节点
                tail = head;
        } else { 
          	// 把旧的尾节点设为node的前驱节点
            node.prev = t;
          	// 利用CAS把node节点设为尾节点
            if (compareAndSetTail(t, node)) {
              	// 将新的node节点作为旧的尾节点的后继节点。 pred <-> node
                t.next = node;
                return t;
            }
        }
    }
}

enq 方法采用了非常经典的自旋操作，只有通过CAS把node设为尾节点后，当前线程才能退出该方法，否则的话，当前线程不断尝试，直到能把节点添加到队列中为止，这样就把并行添加变成了串行添加。

获取同步状态：acquireQueued

// 通过自旋方式获取同步状态
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
      	// 默认线程没有被中断过
        boolean interrupted = false;
        for (;;) {
          	// 获取该节点前驱节点p 内部类Node中的方法
            final Node p = node.predecessor();
          	// 如果p是头节点并且能获取到同步状态(tryAcquire由子类实现)
            if (p == head && tryAcquire(arg)) {
              	// 把当前节点设置为头节点
                setHead(node); // head = node; node.thread = null; node.prev = null;
              	// 把p的next设为null，便于GC
                p.next = null; // help GC
              	// 标志位，表示成功获取同步状态，默认是true，表示失败
                failed = false;
              	// 返回该线程在获取到同步状态的过程中有没有被中断过
                return interrupted;
            }
          	// 判断是否挂起当前线程  具体源码参考3.2.1及3.2.2
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 线程被中断过
                interrupted = true;
        }
    } finally {
      	// 如果failed为true，直接移除当前节点
        if (failed)
            cancelAcquire(node);
    }
}

首先获取当前节点的前驱节点，如果前驱节点是头节点，有两种情况

1. 默认空的头节点，说明此时是同步队列中的第一个线程去尝试获取同步状态。
2. 获取到同步状态的节点，然后再一次调用子类重写的tryAcquire方法去获取同步状态，如果成功获取同步状态，则把当前节点设为头节点。

如果当前节点的前驱节点不是头节点或者没有获取到同步状态的话，就要调用shouldParkAfterFailedAcquire方法挂起当前线程。

注：为什么只有前驱节点为头节点才能尝试获取同步状态？

• 首先队列这种数据结构要保证FIFO的基本原则。
• 其次头节点是当前获取到同步状态的节点，只有在头节点释放同步状态，才能通知后继节点可以进入同步状态。

检查同步状态失败是否需要阻塞线程：shouldParkAfterFailedAcquire

// 如果线程获取同步状态失败就要检查它的节点status，要保证prev = node.prev
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
  	// 获取当前节点的前驱节点的waitStatus
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
         * 如果前驱节点的ws = SIGNAL，表示前驱节点释放后会唤起当前线程，
         * 可以安全的挂起当前线程，如果前驱状态不是SIGNAL，node还要参加同步状态的争夺
         */
        return true; // 能够挂起当前线程直接返回true
    if (ws > 0) { // ws == CANCELLED
        /*
         * 前驱节点的ws > 0，说明ws = CANCELLED，表示前驱线程被取消，
         * 继续往前遍历，直到找到一个有效节点（前驱节点的 ws <= 0）作为node的前驱节点
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * 如果前驱正常，那就把前驱的状态设置成SIGNAL。CAS可能失败，pred可能刚释放锁
         * SIGNAL表示前驱节点释放同步状态会唤醒当前节点
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

总结：这段代码用来检测是否挂起当前线程，分三种情况

• 前驱节点的ws = SINGAL ：表示前驱节点释放同步状态的时候会唤醒当前节点，可以安全挂起当前线程。
• 前驱节点被取消：那就从前驱节点继续往前遍历，直到找到第一个ws <= 0的节点。
• 前驱节点的ws = 0：表示前驱节点获取到同步状态，当前线程不能挂起，因该尝试去获取同步状态，前驱节点的同步状态的释放正好可以让当前节点进行获取，所以使用CAS把前驱节点的ws设为SINGAL，另外如果ws = PROPAGATE，说明以共享模式进行传播，也需要使用CAS把ws设置为SINGAL。

挂起当前线程并检查当前线程是否被中断：parkAndCheckInterrupt

// 挂起当前线程并判断线程是否被中断过
private final boolean parkAndCheckInterrupt() {
  	// 调用LockSupport.park方法挂起当前线程，返回该线程是否被中断过，如果被中断过，直接设置interrupted = true
    LockSupport.park(this);
    return Thread.interrupted();
}

从同步队列中移除无效的节点：cancelAcquire

private void cancelAcquire(Node node) {
    // 当前节点不存在的话直接忽略
    if (node == null)
        return;

  	// 把当前节点的线程设置为null
    node.thread = null;

    // 获取当前节点的前驱节点pred
    Node pred = node.prev;
  	// 如果pred的ws > 0，直接跳过pred继续往前遍历，直到pred的ws <= 0
    // 找到第一个没有被取消的节点（有效节点）
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    // 保存pred的原始后继节点，在CAS更新pre的后继节点将会用到predNext
    Node predNext = pred.next;

    // 把node节点的ws设为CANCELLED
    // 在此后其他线程见到此节点的状态，将会路过此节点。在此之前其他线程不受影响
    node.waitStatus = Node.CANCELLED;

    // 如果node是尾节点，则尝试将与node最近的有效节点pred设置为新的尾节点
    if (node == tail && compareAndSetTail(node, pred)) {
      	// 上面的CAS成功，pred就是最新的尾节点，尾节点的后继节点为null
        // 因此CAS将pred的后继节点设为null,而之前的 “while (pred.waitStatus > 0)”循环已经将其前驱节点更新了。
        compareAndSetNext(pred, predNext, null);
    } else {
        int ws;
      	// pred不是头节点 && pred.wx = SINGAL && pred的线程不为空
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
          	// 利用CAS把node的next设为pred的next节点
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
          	// node是头节点，唤起它的后继节点
            unparkSuccessor(node);
        }

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

总结：分为三种情况进行考虑

• node本身就是尾节点,直接把node的prev设置为尾节点.
• node的prev不是头节点,直接把pred和node的next进行连接.
• node的prev是头节点,使用unparkSuccessor唤醒后继节点.

unparkSuccessor

// 如果node存在唤醒它的后继节点
private void unparkSuccessor(Node node) {
		// 获取node的ws，如果ws < 0，使用CAS把node的ws设为0，表示释放同步状态
  	int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

  	// 获取node的后续节点s，如果next是null或者被取消了，就从tail开始向上查找
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
      	// 从同步队列的尾部开始遍历直到找到距node最近的满足 ws <= 0的节点t，把t赋给s
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
  	// 如果s不为null && s的ws <= 0，直接唤醒s的线程
    if (s != null)
        LockSupport.unpark(s.thread);
}

selfInterrupt

如果执行完acquireQueued方法返回线程被中断过,那线程最后要进行自我中断一下.

static void selfInterrupt() {
    Thread.currentThread().interrupt();
}

其他获取同步状态的方法

响应式中断获取同步状态acquireInterruptibly

// 当前线程被中断后，直接抛出异常，否则的话，再次调用tryAcquire方法获取同步状态
public final void acquireInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

doAcquireInterruptibly

// 以独占模式获取同步状态，线程被中断直接抛出异常
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);
    }
}

指定时间内获取同步状态: tryAcquireNanos

// 以独占模式获取同步状态，线程被中断，直接抛出异常，如果再指定时间内没有获取到同步状态，
// 直接返回false，表示获取同步状态失败
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);
}

doAcquireNanos

private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
  	// 如果指定时间nanosTimeOut <= 0，表示已经超时，直接返回false
    if (nanosTimeout <= 0L)
        return false;
  	// 
    final long deadline = System.nanoTime() + nanosTimeout;
    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 true;
            }
            nanosTimeout = deadline - System.nanoTime();
            if (nanosTimeout <= 0L)
                return false;
            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

释放同步状态的方法：release

public final boolean release(int arg) {
  	// 尝试释放同步状态(同步组件需要重写tryRelease)
    if (tryRelease(arg)) {
        Node h = head;
      	// 所有的节点在将自己挂起之前，都会将前置节点设置成 SIGNAL，希望前置节点释放的时候，唤醒自己。
        // 如果前置节点是 0 ，说明前置节点已经释放过了。不能重复释放了，后面将会看到释放后会将 ws 修改成0
        if (h != null && h.waitStatus != 0)
          	// 唤醒后继节点
						unparkSuccessor(h);
        return true;
    }
    return false;
}

共享式

独占式和共享式的最大不同就是在同一时刻能否有多个线程获取同步状态，通过调用acquireShared方法获取同步状态

public final void acquireShared(int arg) {
    // tryAcquireShared是留给子类去重写的,如果tryAcquireShared方法返回值<0,说明获取同步状态失败
  	if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

doAcquireShared

// 以共享非中断获取同步状态
private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                  	// 传播唤醒的动作
                    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);
    }
}

setHeadAndPropagate

private void setHeadAndPropagate(Node node, int propagate) {
  	// 保存当前的头节点
    Node h = head; // Record old head for check below
  	// 把当前节点设为头节点
    setHead(node);
   	// 这里有三种情况执行唤醒操作：
  	// 1.propagate > 0,代表后继节点需要被唤醒
  	// 2.h节点的ws < 0 或者 h = null
    // 3.新的头节点为空 或者 新的头节点的ws < 0
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
      	// 找到当前节点的后继节点s
        Node s = node.next;
      	// s=null 或者 s是共享模式,调用doReleaseShared方法唤醒后继线程
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

doReleaseShared

private void doReleaseShared() {
    /*
     * 注意这里的头节点已经是上面新设定的头节点了，从这里可以看出，如果propagate = 0，
     * 不会进入doReleaseShared方法，那就由共享式变成了独占式
     */
    for (;;) { // 死循环，直到满足h = head才退出
        Node h = head;
      	// 前提条件：当前的头节点不为null && h不是尾节点
        if (h != null && h != tail) {
            int ws = h.waitStatus;
          	// 如果当前头节点为SINGAL状态。
            if (ws == Node.SIGNAL) {
              	// 利用CAS把h的ws设为0，以后就不会再次唤醒后继节点了
              	// 这一步是为了解决并发问题，保证只unpark一次。
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
              	// 唤醒头节点的后继节点
                unparkSuccessor(h);
            }
          	// 如果h的ws=0，就把h的ws设为PROPAGATE，表示可以向后传播唤醒
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
      	// 如果头节点没有发生变化，表示设置成功，可以退出循环
      	// 如果头节点发生了变化，可能被唤醒的其他节点重新设置了头节点，要进行重试，保证可以传播唤醒信号
        if (h == head)                   // loop if head changed
            break;
    }
}

总结：

如果只是为了应付面试可以只看下面的内容。

AQS类的核心概念

• AQS主要实现了独占式和共享式两种，独占式的同步状态在0与1之间切换，同时只能有一个线程获取锁进行操作，而共享式同一时刻可以有多个线程获取锁。
• AQS会把所有的请求线程构成一个CLH队列，当一个线程执行完毕(lock.unlock)时会激活自己的后继节点，但正在执行的线程并不在队列中，而那些等待执行的线程全部处于阻塞状态。
• AQS采用Node类型的双向链表来确定资源获取线程的排队工作，其中头节点是获取同步状态成功的节点，头节点的线程在释放同步状态时，将会唤醒它的后继节点，而后继节点将会在获取同步状态成功时将自己设置为头节点。而没有成功获取同步状态的线程会成为节点加入该队列的尾部，为了线程安全采用了CAS原子方法更新尾部插入节点。

AQS类最关键的几个变量：

• AQS.head : 同步队列头节点，表示获取同步状态成功节点。
• AQS.tail : 阻塞的尾节点，每个新进来的节点，都插入到最后，形成一个链表。
• AQS.state : 表示当前锁的状态，0表示没有被占用，大于0表示有线程持有当前锁，当大于1的时候表示锁重入。
• Node.waitStatus : 表示节点状态，分为CANCELLED（被取消的节点）、SIGNAL（前驱节点正在占用锁）、CONDITION（）、PROPAGATE（）
• Node.nextWaiter : nextWaiter在描述同步队列的head和tail两个成员变量中只是表示共享型或独占型节点。其主要是在描述Condition条件队列的firstWaiter和lastWaiter两个成员变量中起比较重要的作用，表示下一个等待条件的节点。
• ConditionObject.firstWaiter : condition队列的头节点。
• ConditionObject.lastWaiter : condition队列的尾节点。

AQS独占式获取锁逻辑：简单版

1、首先调用 tryAcquire 方法获取同步状态，AQS并没有实现这个方法，具体的实现由它的子类实现，如：ReentrantLock的Sync类。如果获取同步状态失败执行下面的步骤。

2、调用addWaiter方法把线程封装成一个独占式的Node节点添加到同步队列的尾部。

3、然后调用acquireQueued方法使节点以自旋的方式获取同步状态，如果获取同步状态失败，要挂起线程（被挂起线程的唤醒主要依靠前驱节点的出队或阻塞线程被中断来实现）。

4、最后，线程如果在获取同步状态中和同步队列中被中断过，还要进行一次自我中断。

AQS独占式获取锁逻辑：详细版

acquire(int arg)
  // 调用由子类实现的tryAcquire方法,如果返回true表示获取同步状态成功，那么后面操作将不再继续
	tryAcquire(int) 
	// 首先调用addWaiter方法把线程封装成一个Node节点，通过compareAndSetTail将节点添加到同步队列的尾部
  // 如果添加失败，或者当前尾节点为空的情况下调用enq(final Node node)方法自旋添加
  addWaiter(Node.EXCLUSIVE)
  	// 当addWaiter中尝试快速入队失败的情况下需要调用enq自旋添加尾节点
  	// 自旋添加到尾节点，首先会判断尾节点是否为空，如果为空先初始化，通过CAS设置head
  	// 尾节点不为空后则自旋的通过CAS设置当前节点为尾节点
  	enq(final Node node)
  // 把当前线程封装的节点添加到链表尾部后调用acquireQueued方法使节点以自旋的方式获取同步状态。
	// 主要操作就是获取当前节点的前驱节点，判断其是不是头节点
  // 如果前驱节点是头节点，再判断现在是否能获取到同步状态，如果能获取到则把自己设置为头节点，并且修改标志位
  // 如果不是头节点，或者自身获取同步状态失败的情况下需要调用shouldParkAfterFailedAcquire方法判断是否需要挂起线程
  acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
  	// 判断前驱节点(pred)的waitStatus状态
  	// 1.如果状态为 SIGNAL 可以放心的调用parkAndCheckInterrupt方法挂起当前线程
  	// 2.如果状态> 0 表示前驱节点状态为CANCELLED被取消，则循环向前遍历直到找到一个有效前驱节点
  	// 3.其他节点状态下把当前的前驱节点状态设置为SIGNAL
  	shouldParkAfterFailedAcquire(Node pred, Node node)
      // 挂起当前线程并判断线程是否被中断过
  		// 如果当前线程被中断过，当方法acquireQueued结束的时候会调用cancelAcquire移除当前节点
      parkAndCheckInterrupt()
  	// 从同步队列中移除无效节点
  	// 设置当前节点线程为null，再循环向前遍历，直到找到一个有效的前驱节点，并设置当前节点状态为CANCELLED已取消
  	// 1.如果node是尾节点的情况，尝试将node最近的有效节点pred设置为新的尾节点，成功则再通过CAS将pred(新的尾节点)的后继节点设置为null
  	// 2.如果pred不是头节点，则判断pred的waitStatus状态是否为SIGNAL，如果不是通过CAS将waitStatus设置为SIGNAL，成功的情况下把pred和node.next连接
  	// 3.如果pred是头节点的情况调用unparkSuccessor方法唤醒后继节点
  	cancelAcquire(Node node)
  		// 唤醒后继节点
  		// 如果当前节点的waitStatus < 0 则使用CAS把ws设置为0，表示释放同步状态
  		// 再获取当前节点的后继节点，如果为null或者被取消了则从同步队列的尾部往前查找
  		// 直到找到距离node最近的未取消的节点，如果找到了则唤醒它
  		unparkSuccessor(Node node)
  	
	selfInterrupt() // 如果在执行acquireQueued方法中线程被中断过，需要进行自我中断一下
	

AQS独占式释放锁逻辑

调用tryRelease尝试释放同步状态，然后再唤醒头节点的后继节点线程（主要是将node节点的waitStatus设置为初始值0，并唤醒可用的后继节点）。

AQS共享式获取锁逻辑

AQS共享式释放锁逻辑

赏

谢谢你请我吃糖果

支付宝

微信