1.简介

AQS是用来构建锁和其他同步组件的基础框架类，JDK中许多的并发工具类都是依赖于AQS，如ReentrantLock,Semaphore,CountLatch等。学习AQS的源码对于concurrent包非常有用。
介绍AQS中独占锁，共享锁的获取和释放实现原理。
AQS的主要使用方式就是继承他作为一个内部辅助类实现同步原语，这样可以简化并发工具的内部实现，屏蔽同步状态管理，线程的排队，等待与唤醒等一些底层操作。

2.设计与实现

同步框架提供两个基本类型的操作acquire和release,acquire表示根据同步器状态请求获取，获取不成功则需要排队等待，获取成功后并且完成操作后需要进行release释放状态让给其他线程。
完成这些，可以抽象出一些基本功能。
1.首先，需要保存状态留给子类去表示具体的含义，并提供查询，设置，修改的原子性操作。
2.其次要能够阻塞，唤醒线程。
3.然后，还需要有一个容器来存放等待的线程。

3.内部结构

3.1 同步状态

state字段可以通过volatile修饰，这样get和set方法具有volatile的语义。

3.2阻塞唤醒线程

在AQS中使用LockSupport类来实现这个功能，LockSupport给每个线程绑定一个类似Semaphore的permit许可数量，不过permit最大为1，初始时permit为0。

3.3线程等待队列

AQS的核心是一个线程等待队列，采用的是一个先进先出的FIFO队列，AQS基于CLH进行修改作为线程等待队列。

3.4ConditionObject

AQS提供了一个ConditionObject类来表示监视器风格的等待通知操作，主要用在Lock中，和传统的监视器的区别在于一个Lock可以创建多个condition.ConditonObject使用相同的内部队列节点，维护在一个单独的条件队列中，当收到signal操作时，将条件队列中的节点转移都等待队列中。

4.内部代码

4.1AQS大体内部结构和方法

class AbstractQueuedSynchronizer {
    static final class Node{}
    private transient volatile Node head;
    private transient volatile Node tail;
    private volatile int state;
    protected final int getState() {
        return state;
    }
    protected final void setState(int newState) {
        state = newState;
    }
    protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }
    private Node enq()
    private void setHead(Node node)
    private void unparkSuccessor(Node node)
    private void doReleaseShared()
    final boolean acquireQueued(final Node node, int arg) 
    private void doAcquireInterruptibly(int arg)
    private boolean doAcquireNanos(int arg, long nanosTimeout)
    private void doAcquireShared(int arg) 
    private void doAcquireSharedInterruptibly(int arg)
    private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
    // 需要子类去实现的方法
    protected boolean tryAcquire(int arg)
    protected boolean tryRelease(int arg) 
    protected int tryAcquireShared(int arg) 
    protected boolean tryReleaseShared(int arg)
    // 对外提供的public方法
    public final void acquire()
    public final void acquireInterruptibly(int arg)()
    public final boolean tryAcquireNanos()
    public final boolean release(int arg)()
    public final void acquireShared(int arg)()
    public final void acquireSharedInterruptibly(int arg)()
    public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)()
    public final boolean releaseShared(int arg) ()
    ...
}

4.2Node

class Node {
        volatile int waitStatus;
        volatile Node prev;
        volatile Node next;
        volatile Thread thread;
        Node nextWaiter;
        ...
}

Node节点表示一个等待节点。
等待节点的状态：
CANCELED表示线程等待已经取消，是唯一一个大于0的状态
SIGNAL需要唤醒next节点，
CONTITION表明线程正在等待一个条件
PROPAGATE用于acquireShared中向后传播

/** 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;
/**
 * waitStatus value to indicate the next acquireShared should
 * unconditionally propagate
 */
static final int PROPAGATE = -3;

4.3state状态的操作

private volatile int state;
protected final int getState() {
    return state;
}
protected final void setState(int newState) {
    state = newState;
}
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}