JAVA的众多锁的机制，包括Semaphore/ReentrantLock/ReentrantReadWriteLock等都是通过 AQS实现的，因为写了上述几个锁实现的源码分析，经常使用到AQS的原理和代码，因此这里做下AQS的源码分析。这样之后再翻看以AQS为基础的各种各样的锁实现就会好理解的多了。
我们结合着源码文件中的注释来看下。
源代码英文注释：
/**
* Provides a framework for implementing blocking locks and related
* synchronizers (semaphores, events, etc) that rely on
* first-in-first-out (FIFO) wait queues. This class is designed to
* be a useful basis for most kinds of synchronizers that rely on a
* single atomic {@code int} value to represent state. Subclasses
* must define the protected methods that change this state, and which
* define what that state means in terms of this object being acquired
* or released. Given these, the other methods in this class carry
* out all queuing and blocking mechanics. Subclasses can maintain
* other state fields, but only the atomically updated {@code int}
* value manipulated using methods {@link #getState}, {@link
* #setState} and {@link #compareAndSetState} is tracked with respect
* to synchronization.
*/
提供一个依赖FIFO等待队列来实现阻塞锁和关联同步机制（信号量、事件等）的框架。该类被作为多数类型的同步机制的一个实用的基础，设计依赖一个atomic类型的int数据来代表一个状态。子类必须实现其protected类型的方法来改变这个状态，这个状态意味着对象被请求或者释放的一个说明。提供了这些，本类的其他方法都用来执行所有的队列和阻塞结构。子类可以维护其他的字段，但只有state状态的原子更新操作通过#getState, #setState, #compareAndSetState 被追踪来实现同步。
AQS的这段类文件中最开始的注释，解释了AQS类的意义和实现手段。
通过一个先进先出的队列和一个内存可见的int类型状态，来提供一个队列的阻塞结构，作为众多同步机制（Semaphore/ReentrantLock等）的基础算法结构。
源代码英文注释：
<p>This class supports either or both a default <em>exclusive</em>
* mode and a <em>shared</em> mode. When acquired in exclusive mode,
* attempted acquires by other threads cannot succeed. Shared mode
* acquires by multiple threads may (but need not) succeed. This class
* does not "understand" these differences except in the
* mechanical sense that when a shared mode acquire succeeds, the next
* waiting thread (if one exists) must also determine whether it can
* acquire as well. Threads waiting in the different modes share the
* same FIFO queue. Usually, implementation subclasses support only
* one of these modes, but both can come into play for example in a
* {@link ReadWriteLock}. Subclasses that support only exclusive or
* only shared modes need not define the methods supporting the unused mode.
AQS类支持两种模式，独享模式和分享模式，默认是独享即排它模式。排它模式时，除了当前占用线程外，其他的线程的尝试请求将失败。共享模式下，多个线程的请求将会成功。这个类不能“理解”这种不同，除了这样一种机械的功能，那就是当一个共享模式的请求成功时，另一个等待线程（如果存在的话）必须决定它是否能够请求。不同类型的线程等待使用的是同样的FIFO队列。一般来说，子类只需要实现其中的一种模式，共享or排它。但也可以一起生效比如ReadWriteLock。只支持一种模式的子类不需要定义另一种不支持的模式的方法。
了解了基础的概括，我们来深入代码查看具体实现。
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; // 表明线程再等待condition条件的状态 /** * waitStatus value to indicate the next acquireShared should * unconditionally propagate */ static final int PROPAGATE = -3; // 表明下一个acquireShared会无条件的传递 /** * Status field, taking on only the values: * SIGNAL: The successor of this node is (or will soon be) * blocked (via park), so the current node must * unpark its successor when it releases or * cancels. To avoid races, acquire methods must * first indicate they need a signal, * then retry the atomic acquire, and then, * on failure, block. * CANCELLED: This node is cancelled due to timeout or interrupt. * Nodes never leave this state. In particular, * a thread with cancelled node never again blocks. * CONDITION: This node is currently on a condition queue. * It will not be used as a sync queue node * until transferred, at which time the status * will be set to 0. (Use of this value here has * nothing to do with the other uses of the * field, but simplifies mechanics.) * PROPAGATE: A releaseShared should be propagated to other * nodes. This is set (for head node only) in * doReleaseShared to ensure propagation * continues, even if other operations have * since intervened. * 0: None of the above * * The values are arranged numerically to simplify use. * Non-negative values mean that a node doesn't need to * signal. So, most code doesn't need to check for particular * values, just for sign. * * The field is initialized to 0 for normal sync nodes, and * CONDITION for condition nodes. It is modified using CAS * (or when possible, unconditional volatile writes). */ volatile int waitStatus; /** * Link to predecessor node that current node/thread relies on * for checking waitStatus. Assigned during enqueuing, and nulled * out (for sake of GC) only upon dequeuing. Also, upon * cancellation of a predecessor, we short-circuit while * finding a non-cancelled one, which will always exist * because the head node is never cancelled: A node becomes * head only as a result of successful acquire. A * cancelled thread never succeeds in acquiring, and a thread only * cancels itself, not any other node. */ volatile Node prev; /** * Link to the successor node that the current node/thread * unparks upon release. Assigned during enqueuing, adjusted * when bypassing cancelled predecessors, and nulled out (for * sake of GC) when dequeued. The enq operation does not * assign next field of a predecessor until after attachment, * so seeing a null next field does not necessarily mean that * node is at end of queue. However, if a next field appears * to be null, we can scan prev's from the tail to * double-check. The next field of cancelled nodes is set to * point to the node itself instead of null, to make life * easier for isOnSyncQueue. */ volatile Node next; /** * The thread that enqueued this node. Initialized on * construction and nulled out after use. */ volatile Thread thread; /** * Link to next node waiting on condition, or the special * value SHARED. Because condition queues are accessed only * when holding in exclusive mode, we just need a simple * linked queue to hold nodes while they are waiting on * conditions. They are then transferred to the queue to * re-acquire. And because conditions can only be exclusive, * we save a field by using special value to indicate shared * mode. */ 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; } }