AQS负责管理同步器类中的状态，它管理了一个整数状态信息，可以通过getState，setState以及compareAndSetState等protected方法来操作。这个整数可以用来表示任意状态。比如，ReentrantLock用它来表示所有者线程已经重复获取该锁的次数，Semaphore用它来表示剩余的许可数量，FutureTask用它来表示任务的状态(尚未开始、正在运行已完成以及已取消)。
如果某个同步器支持独占的获取操作，那么需要实现一些保护方法，包括tryAcquire、tryRelease和isHeldExclusively等，而对于支持共享获取的同步器，则应该实现tryAcquireShared和tryReleaseShared等方法。AQS中的acquire、acquireShared、release和releaseShared等方法都将调用这些方法在子类中带有前缀try的版本来判断某个操作是否能执行。
AQS中获取操作和释放操作的标准形式：首先，判断当前状态是否允许获得操作；其次，更新同步器的状态。
boolean acquire() throws InterruptedException
{
while(当前状态不允许获取操作)
{
if(需要阻塞获取请求)
{
如果当前线程不在队列中，则将其插入队列
阻塞当前线程
}
else
{
返回失败
}
}
可能更新同步器的状态
如果线程位于队列中，则将其移除队列
返回成功
}
void release()
{
更新同步器的状态
if(新的状态允许某个被阻塞的线程获取成功)
{
解除队列中一个或多个线程的阻塞状态
}
}
示例一：使用AbstractQueuedSynchronizer实现的二元闭锁：
public class OneShotLatch
{
private final Sync sync = new Sync();
public void signal()
{
sync.releaseShared(0);
}
public void await() throws InterruptedException
{
sync.acquireSharedInterruptibly(0);
}
private class Sync extends AbstractQueuedSynchronizer
{
protected int tryAcquireShared(int ignored)
{
//如果闭锁是开的(state == 1)，这个操作成功，否则失败
return (getState() == 1) ? 1 : -1;
}
protected boolean tryReleaseShared(int ignored)
{
//打开闭锁
setState(1);
//现在其他线程可以获取该闭锁
return true;
}
}
}
在OneShotLatch中，AQS状态用来表示闭锁状态，关闭0，打开1。await方法调用AQS的acquireSharedInterruptibly，然后接着调用OneShotLatch中的tryAcquireShared方法。若之前已经打开了闭锁，则tryAcquireShared将返回成功并允许线程通过，否则返回一个表示获取操作失败的值。acquireSharedInterruptibly方法在处理失败的方式，是把这个线程放入等待线程队列中。
java.util.concurrent中的所有同步器类都没有直接扩展AQS，而是都将他们的相应功能委托给私有的AQS子类来实现。如开篇的类图所示。
ReentrantLock
ReentrantLock只支持独占方式的获取操作，因此它实现了tryAcquire、tryRelease和isHeldExclusively。
源码一：基于非公平的ReentrantLock实现tryAcquire
当一个线程尝试获取锁时，tryAcquire首先检查锁的状态。若未被持有，它将尝试更新锁的状态以表示锁已经被持有；
若锁状态表明它已经被持有，并且如果当前线程是锁的所有者，则获取计数递增，若不是当前持有者，则获取失败。
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;
}
Semaphore与CountDownLatch
Semaphore将AQS的同步状态用于保存当前可用许可的数量。
CountDownLatch使用AQS的方式与Semaphore相似：在同步状态中保存的是当前的计数值，countDown方法调用release，从而减少计数值，并且当计数值为零时，解除所有等待线程的阻塞。await调用acquire，当计数器为零时，acquire将立即返回，否则将阻塞。
源码二：Semaphore中的tryAcquireShared与tryReleaseShared：
final int tryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
FutureTask
Future.get的语义非常类似于闭锁的语义---如果发生了某个事件(由FutureTask表示的任务执行完成或被取消)，那么线程就可以恢复执行，否则这些线程将停留在队列中并直到该事件发生。
FutureTask中，AQS同步状态被用来保存任务的状态，例如正在运行、已完成或已取消。此外，它还维护了一个引用，指向正在执行计算任务的线程(如果它当前处于运行状态)，因此，如果任务取消，该线程就会中断。
ReentrantReadWriteLock
ReadWriteLock接口表示存在两个锁：一个读锁，一个写锁。读锁上的操作使用共享的获取方法与释放方法，写锁上的操作将使用独占的获取方法和释放方法。
AQS内部维护一个等待线程队列，其中记录了某个线程请求的是独占访问还是共享访问。在ReentrantReadWriteLock中，当锁可用时，如果位于队列头部的线程执行写入操作，那么线程会得到这个锁，如果位于队列头部的线程执行读取访问，那么队列中在这个线程之前的所有线程都将获得这个锁。
