AQS全称是AbstractQueuedSynchronizer，是JDK提供的一个同步器设计框架，很多并发数据结构如ReentrantLock、ReentrantReadWriteLock、Semaphore等都是基于AQS来实现的，下面来分析一下AQS的原理。
一、底层数据结构
AQS底层维护了一个state（代表共享资源）和一个CLH队列（代表线程等待队列）
state：state是一个volatile int型变量，用以表示共享资源的使用情况。
head、tail：分别表示CLH队列的头节点和尾节点。关于CLH队列原理可以看这篇博客：
private transient volatile Node head;
private transient volatile Node tail;
private volatile int state;
AQS定义了两种资源：
一种是Exclusive（独占方式，同一时间只有一个线程能够访问，比如ReentrantLock）；
一种是Share（共享方式，同一时间允许多个线程访问，比如Semaphore）。
二、AQS原理
AQS被定义为一个同步器框架，那么为什么说AQS是一个“框架”呢，框架的定义应该是使用者根据框架的要求去实现一些业务逻辑，然后底层由框架自己去完成，比如使用Hadoop大数据框架的时候，我们只需要定义好Map/Reduce函数就可以了，其他复杂的底层操作就有Hadoop帮我们完成。AQS也应该是这样一个东西，事实上，AQS也确实是这样做的，它只需要开发者实现其中的几个函数，其他的底层操作比如CLH队列操作、CAS自旋等等都是由AQS框架来实现。
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}
上面的几个方法就是AQS要我们实现的函数，这几个方法都是AQS提供给开发者编写代码逻辑的，因此每个方法里面都定义为直接抛出UnsupportedOperationException，下面解释一下这几个函数的作用。
tryAcquire：尝试获取独占资源。成功返回true，失败返回false。
tryRelease：尝试释放独占资源。成功返回true，失败返回false。
tryAcquireShared：尝试获取共享资源。成功返回一个非负数，代表剩余资源（0就表示没有可用资源），负数表示失败。
tryReleaseShared：尝试释放共享资源。成功返回true，失败返回false。
isHeldExclusively：判断线程是否正在独占资源。
对于独占方式的同步器，只需要实现tryAcquire-tryRelease；而对于共享方式的同步器则只需要实现tryAcquireShared-tryReleaseShared就行了，当然如果自定义同步器需要同时实现独占和共享方式的话也可以，比如读写锁ReentrantReadWriteLock，其中读锁是共享的，写锁是独占的。
三、源码解析
AQS中对于资源获取的顶层接口是acquire-release和acquireShare-releaseShare，下面从这些顶层接口来分析：
1、acquire
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
代码逻辑：
（1）尝试获取资源（tryAcquire），成功则返回，失败则跳转到（2）
（2）请求将该线程加入线程等待队列的尾部，并标记为独占模式（addWaiter(Node.EXCLUSIVE)），并不断请求队列智斗获取到资源，如果该过程被打断，则跳转到（3），失败则返回。
（3）自我中断（selfInterrupt）
（4）完成
2、release
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
代码逻辑：
（1）尝试释放资源，如果成功则跳转到（2），失败则返回false
（2）获取线程等待队列的头节点，如果头节点线程不为空且处于等待状态，则唤醒该线程（unparkSuccessor）
3、acquireShared
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
代码逻辑：
（1）尝试获取共享资源，如果获取失败则调用doAcquireShared自旋来请求共享资源。
4、releaseShared
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
代码逻辑：
（1）尝试释放共享资源，释放成功则唤醒等待队列中的后继节点来获取资源。
5、如果需要响应中断程序的话，AQS还提供了acquireInterruptibly和acquireSharedInterruptibly函数来响应。
4、实际例子：ReentrantLock解析
一般用AQS来实现同步器主要使用内部类的方式来实现的，ReentrantLock里面就是一个比较经典的实现，看一下这个内部类的实现源码：
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
@ReservedStackAccess
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;
}
@ReservedStackAccess
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
protected final boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
final boolean isLocked() {
return getState() != 0;
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
这里定义的Sync同步器类仍然是一个抽象类，是因为ReentrantLock同时支持公平锁和非公平锁，而这两种同步方式是不一样的，所以先定义一个Sync类作为两种实现的基类，后面会看到具体的公平锁和非公平锁的实现。
由于ReentrantLock本身是一个独享锁，因此Sync类主要重写了AQS里面的tryRelease和isHeldExclusively方法，同时定义了非公平锁的nonfairTryAcquire方法作为请求资源的方法。
非公平锁实现：
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
其实基类Sync完完全全就是一个非公平锁的实现，所以NonfairSync并没有新代码，tryAcquire直接调用nonfairTryAcquire。
公平锁实现：
static final class FairSync extends Sync {
@ReservedStackAccess
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
公平锁与非公平锁的区别也就是资源请求的方式不一样，所以在基类Sync的基础上重写tryAcquire方法，顺序唤醒等待队列中的线程。
基于AQS实现了公平锁和非公平锁之后，如何实现上锁和解锁的功能也就十分简单了，源码直接用一行代码就实现了：
public void lock() {
sync.acquire(1);
}
public void unlock() {
sync.release(1);
}