AQS 类中的属性以及方法说明

AbstractQueuedSynchronizer 类的描述信息

提供一个框架，用于实现依赖先进先出（FIFO）等待队列的阻塞锁和相关同步器（信号量、事件等）。此类被设计为大多数类型的同步器的有用基础，这些同步器依赖于单个原子 int 值来表示状态。子类必须定义更改此状态的受保护方法，并定义该状态在获取或释放此对象方面的含义。鉴于这些，本类中的其他方法执行所有排队和阻塞机制。子类可以维护其他状态字段，但仅跟踪使用方法 getState()、setState(int)和compareAndSetState(int,int) 操作的原子更新的 int 值。

子类应定义为非公共内部助手类，用于实现其封闭类的同步属性。AbstractQueuedSynchronizer类不实现任何同步接口。相反，它定义了 acquiredInterruptible() 等方法，具体锁和相关同步器可以根据需要调用这些方法来实现它们的公共方法。

此类支持默认的独占模式和共享方式中的一种或两种。当以独占模式获取时，其他线程尝试的获取无法成功。由多个线程获取的共享模式可能（但无需）成功。除了在机械意义上，这个类不理解这些差异，当共享模式获取成功时，下一个等待线程（如果存在）也必须确定它是否也可以获取。在不同模式下等待的线程共享相同的FIFO队列。通常，实现子类只支持这些模式之一，但是两者都可以在ReadWriteLock中发挥作用。通常，实现子类只支持其中一种模式，但两者都可以在 ReadWriteLock 中发挥作用。仅支持独占模式或共享模式的子类不需要定义支持未使用模式的方法。

该类定义了一个嵌套的 ConditionObject 类，该类可由支持独占模式的子类用作 Condition 实现，其中方法 isHeldExclusive() 报告是否以独占方式保持与当前线程的同步，方法release(int)与当前调用getState()值完全释放此目的，和acquire(int) ，给定此保存的状态值，最终将此对象恢复到其先前获取的状态。AbstractQueuedSynchronizer方法将创建此类条件，因此如果不能满足此约束，请勿使用该约束。 ConditionObject的行为当然取决于其同步器实现的语义。

此类提供内部队列的检查、检测和监视方法，以及条件对象的类似方法。这些可以根据需要使用 AbstractQueuedSynchronizer 作为其同步机制导出到类中。

此类的序列化仅存储底层原子整数维护状态，因此反序列化对象具有空线程队列。需要可序列化的典型子类将定义一个 readObject 方法，该方法在反序列化时将其还原为已知的初始状态。

示例用法:

使用这个类用作同步的基础上，重新定义以下方法，如适用，通过检查和/或修改使用所述同步状态getState() ， setState(int)和/或compareAndSetState(int, int) ：

tryAcquire(int)
tryRelease(int)
tryAcquireShared(int)
tryReleaseShared(int)
isHeldExclusively()

每个这些方法默认抛出UnsupportedOperationException 。这些方法的实现必须是线程安全的，通常应该是短的而不是阻止的。定义这些方法是唯一支持使用此类的方法。所有其他方法都被声明为final ，因为它们不能独立变化。
您还可以找到来自继承的方法AbstractOwnableSynchronizer有用跟踪线程拥有独家同步的。我们鼓励您使用它们 - 这样可以使监控和诊断工具帮助用户确定哪些线程持有锁定。
即使该类基于内部FIFO队列，它也不会自动强制执行FIFO获取策略。独占同步的核心形式如下：

Acquire:
    while (!tryAcquire(arg)) {
       <em>enqueue thread if it is not already queued</em>;
       <em>possibly block current thread</em>;
    }
Release:
    if (tryRelease(arg))
       <em>unblock the first queued thread</em>;

（共享模式类似，但可能涉及级联信号。）

因为在采集检查入队之前调用，所以新获取的线程可能闯入其他被阻塞和排队的。但是，如果需要，您可以通过内部调用一个或多个检查方法来定义tryAcquire和/或tryAcquireShared来禁用驳船，从而提供一个合理的 FIFO采购订单。特别地，最公平同步器可以定义tryAcquire返回false如果hasQueuedPredecessors() （具体地设计成由公平同步器中使用的方法）返回true 。其他变化是可能的。

吞吐量和可扩展性通常对于默认的驳船（也称为贪心，放弃和车队避免）战略来说是最高的。虽然这不能保证是公平的或无饥饿的，但较早排队的线程在稍后排队的线程之前被允许重新侦听，并且每次重新提供对于传入线程成功的机会。此外，虽然获取在通常意义上不“旋转”，但是在阻止之前它们可以执行多个tryAcquire tryAcquire与其他计算的交互。当独占同步只是简单地持有时，这样可以提供旋转的大部分好处，而没有大部分负债。如果需要，您可以通过以前通过“快速路径”检查获取方法的调用进行扩充，可能预先检查hasContended()和/或hasQueuedThreads() ，以便只有在同步器可能不被竞争的情况下才能进行。

该类为同步提供了一个高效和可扩展的基础，部分原因是可以依靠int状态，获取和释放参数以及内部FIFO等待队列的同步器的使用范围。当这不足够时，您可以使用atomic类，您自己的自定义Queue类和LockSupport类阻止支持从较低级别构建同步器。

用法示例：
这是一个不可重入互斥锁类，它使用零值来表示解锁状态，一个表示锁定状态。虽然不可重入锁不严格要求记录当前的所有者线程，但是这样做无论如何使得使用更容易监视。它还支持条件并公开其中一种仪器方法：

class Mutex implements Lock, java.io.Serializable {
  // Our internal helper class
  private static class Sync extends AbstractQueuedSynchronizer {
    // Reports whether in locked state
    protected boolean isHeldExclusively() {
      return getState() == 1;
    }
    // Acquires the lock if state is zero
    public boolean tryAcquire(int acquires) {
      assert acquires == 1; // Otherwise unused
      if (compareAndSetState(0, 1)) {
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
      }
      return false;
    }
    // Releases the lock by setting state to zero
    protected boolean tryRelease(int releases) {
      assert releases == 1; // Otherwise unused
      if (getState() == 0) throw new IllegalMonitorStateException();
      setExclusiveOwnerThread(null);
      setState(0);
      return true;
    }
    // Provides a Condition
    Condition newCondition() { return new ConditionObject(); }
    // Deserializes properly
    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();
  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));
  }
}

这是一个类似CountDownLatch的闩锁类，只是它只需要一个signal才能触发。因为锁存器是非排他的，它使用shared获取和释放方法。

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

AbstractQueuedSynchronizer 属性以及方法

相关方法 --- 用于不同版本的 acquire 的实用程序

    //==========================  用于不同版本的 acquire 的实用程序  ==========================

    /**
     * 取消正在尝试获取锁的节点（一般用于线程被打断，需要立即返回的情况）
     */
    private void cancelAcquire(Node node) {
        // 如果节点不存在，则忽略
        if (node == null)
            return;

        node.thread = null;

        /**
         * 跳过已取消节点的前置任务
         */
        Node pred = node.prev;
        
        // pred.waitStatus > 0 表示前置节点也被取消了  （剔除前面 所有取消的节点）
        // 目的：找到 node 前面第一个未取消的节点
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // 当前取消节点的前置节点的后继节点（不一定是当前节点）
        Node predNext = pred.next;

        // 当前节点 node 设置为： 取消状态
        node.waitStatus = Node.CANCELLED;

        // 如果当前节点为 tail (说明为尾节点)，将当前节点的剔除掉
        if (node == tail && compareAndSetTail(node, pred)) {
            //设置前置节点的next 为 null （因为现在它为 tail  尾节点）
            compareAndSetNext(pred, predNext, null);
        } else {
            // 如果当前节点不是尾节点

            int ws;
            // 当 前置节点不是 head
            // 并且 前置节点的waitStatus状态是 SIGNAL  或者 （前置节点的waitStatus状态不是取消状态 并且 设置前置状态为 SIGNAL 成功）
            // 并且 前置节点的 thread 不为空
            if (pred != head &&
                    ((ws = pred.waitStatus) == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                    pred.thread != null) {
                Node next = node.next;
                // 将当前节点的next 设置为前置节点next  （主要是跳过当前节点）
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {
                // 唤醒后继节点
                unparkSuccessor(node);
            }
            //将当前节点的next设置为自己（闭环），便于垃圾回收
            node.next = node; // help GC
        }
    }

    /**
     * 检查并更新未能获取的节点的状态。如果线程应阻塞，则返回true。这是所有采集回路中的主要信号控制。需要pred==node.prev。
     * 维护节点状态
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * 当前节点的前驱节点状态是 Single （Single 代表，释放锁时，唤醒后继节点），
             * 则后续执行（parkAndCheckInterrupt）挂起等待
             */
            return true;
        if (ws > 0) {
            /*
             * ws > 0 代表前置节点已取消，剔除该前置节点
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus必须为0或PROPAGATE ， 表示我们需要信号，但还没有 park。
             * 调用者将需要重试，以确保它不能获取之前 park。
             *
             * 设置前驱节点的 waitStatus =  SIGNAL （Single 代表，释放锁时，唤醒后继节点）
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

    /**
     * 中断当前线程
     */
    static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

    /**
     * 唤醒当前线程，并返回中断状态
     */
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

    /**
     * 不同的获取方式，不同的独占/共享和控制模式。每一个都大致相同，但令人讨厌的是不同。
     * 由于异常机制(包括确保我们在tryAcquire抛出异常时取消)和其他控制的相互作用，
     * 只有一点点因子分解是可能的，至少不会对性能造成太大影响。
     */



    /**
     * 以独占不可中断模式获取队列中已存在的线程。用于条件等待方法和acquire方法。
     */
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                // 获取前置节点是否为 head ；
                //      是：尝试获取锁
                //      否：向下执行，继续阻塞（park）
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    // 该节点获取锁成功

                    // 该节点出队
                    setHead(node);

                    // 将之前的虚节点 next 置为空，方便垃圾回收
                    p.next = null; // help GC
                    failed = false;

                    // 返回中断状态
                    return interrupted;
                }
                // 保证前置节点的状态是 SIGNAL ，保证前置节点释放之后，唤醒后续节点;
                // 阻塞当前线程（等待唤醒后继续执行）
                if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                    //当线程被中断，则返回中断状态
                    interrupted = true;
            }
        } finally {
            //当线程获取锁成功后，执行失败，则取消该节点
            if (failed)
                cancelAcquire(node);
        }
    }

    /**
     *  以独占可中断模式获取（可响应中断）。
     */
    private void doAcquireInterruptibly(int arg) throws InterruptedException {
        // 将当前节点加入等待队列
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                // 获取前置节点是否为 head ；
                //      是：尝试获取锁
                //      否：向下执行，继续阻塞（park）
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    // 该节点获取锁成功

                    // 该节点出队
                    setHead(node);

                    // 将之前的虚节点 next 置为空，方便垃圾回收
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                // 保证前置节点的状态是 SIGNAL ，保证前置节点释放之后，唤醒后续节点;
                // 阻塞当前线程（等待唤醒后继续执行）
                if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                    //当线程被中断，则抛出异常
                    throw new InterruptedException();
            }
        } finally {
            //当线程获取锁成功后，执行失败，则取消该节点
            if (failed)
                cancelAcquire(node);
        }
    }

    /**
     * 以独占计时模式获取。
     */
    private boolean doAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
        // 判断最大等待时间是否合规
        if (nanosTimeout <= 0L)
            return false;
        // 计算出 截止时间
        final long deadline = System.nanoTime() + nanosTimeout;
        // 加入等待队列
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                // 获取前置节点是否为 head ；
                //      是：尝试获取锁
                //      否：向下执行，继续阻塞（park）
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    // 该节点获取锁成功

                    // 该节点出队
                    setHead(node);

                    // 将之前的虚节点 next 置为空，方便垃圾回收
                    p.next = null; // help GC
                    failed = false;
                    return true;
                }
                //计算距离截止时间还有多少时间
                nanosTimeout = deadline - System.nanoTime();
                // 判断等待时间是否用完，用完则返回 false（因为这一步的时候，还没有获取锁）
                if (nanosTimeout <= 0L)
                    return false;

                // 1.保证前置节点的状态是 SIGNAL ，保证前置节点释放之后，唤醒后续节点;
                // 2.判断剩余的时间小于系统定义的自旋时间，
                // 小于：线程执行自旋方式获取锁（for循环）
                // 否则：阻塞当前线程（阻塞 nanosTimeout 时间，时间到了，自动唤醒）
                if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                //响应线程的中断
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            //当线程获取锁成功后，执行失败，则取消该节点
            if (failed)
                cancelAcquire(node);
        }
    }

    /**
     * 在共享不中断模式下获取。【忽略中断】
     *
     * 1.为当前线程创建排队节点，加入等待队列
     * 2.for循环开始：判断当前节点的前置节点是否为 head？
     *            是: 尝试获取锁
     *                    获取成功，节点出队，
     *                    获取失败，执行步骤 3
     *            否：执行步骤 3
     * 3.判断当前节点的前置节点 waitStatus == Node.SIGNAL
     *            如果不是，设置为 Node.SIGNAL ，执行步骤 2
     *            如果是， 阻塞（park）当前节点的线程，等待唤醒；节点被唤醒之后，执行步骤 2
     *
     */
    private void doAcquireShared(int arg) {
        // 加入到等待队列中
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false; //线程的中断标识
            for (;;) {
                // 判断当前节点的前置节点是否是 head
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 设置 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);
        }
    }

    /**
     * 在共享可中断模式下获取。
     */
    private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    /**
     * 以共享定时模式获取。
     */
    private boolean doAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
        if (nanosTimeout <= 0L)
            return false;
        //截止时间
        final long deadline = System.nanoTime() + nanosTimeout;
        // 加入队列
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return true;
                    }
                }
                //距离截止时间还有多少时间
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L) //时间用完，直接返回 false
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) &&
                        // 如果剩余的时间小于系统定义的自旋时间，才会执行自旋（for循环）；
                        // 否则：阻塞当前 nanosTimeout ，时间到了，自动唤醒；
                        nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

精彩极了

There is only one heroism in the world: to see the world as it is and to love it.

AQS 类中的属性以及方法说明