Java并发之AQS（AbstractQueuedSynchronizer）原理讲解

一、什么是AQS？

    AQS的全称是AbstractQueuedSynchronizer，即抽象队列同步器，其底层是volatile与CAS，而其上层则是基于该抽象类构建的许多并发组件，如ReentrantLock、Semaphore等。AQS自身实现了一些基本方法，还剩余一些面向上层的方法，这些方法需要继承该抽象类的同步组件去实现。
    volatile原理链接

    CAS原理链接

    AQS最核心的数据结构是一个volatile int state 和 一个FIFO线程等待对列。state代表共享资源的数量，如果是互斥访问，一般设置为1，而如果是共享访问，可以设置为N（N为可共享线程的个数）；而线程等待队列是一个双向链表，无法立即获得锁而进入阻塞状态的线程会加入队列的尾部。当然对state以及队列的操作都是采用了volatile + CAS + 自旋的操作方式，采用的是乐观锁的概念。
    AQS有两种实现方式，一种是独占方式，另一种是共享方式（shared），取决于用户实现什么方法。

    下面来看一下AQS的线程等待队列图



                                                                                （图片来自网络）

二、AQS的核心方法（独占模式为例）

1、获取资源
（1）acquire方法，本方法时ReentrantLock方法的lock方法调用的方法。public final void acquire(int arg) {
if (!tryAcquire(arg) && //尝试获取锁，若获取成功，则state减1，返回true
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //若获取锁不成功，调用addWaiter方法使线程进入等待队列，acquireQueued方法让线程进入阻塞状态
selfInterrupt(); //检查在等待过程中是否有中断，若有中断，则在此时再响应
}（2）tryAcquire方法，本方法需要用户自己实现，但是不抽象的。

protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}

为什么要抛出异常而不是声明为抽象类呢？Programer肯定有他自己的考虑，因为AQS是可选模式的，我们选择的是独占模式，就不需要去重写tryAcquireShared方法，如果我们选的是共享模式，也不需要重写tryAcquire方法，因此AQS虽然是抽象类，但是没有抽象方法，而是用抛出异常的方式代替。
具体重写的方法一般就是对state进行原子操作，若获取资源成功则返回true，否则返回false。
（3）addWaiter方法的主要是把当前线程加入到FIFO等待队列队尾。private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);//创建节点
// 首先尝试快速插入队尾
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {//CAS操作
pred.next = node;
return node;
}
}
enq(node);//若不成功，则尝试以自旋方式插入队尾
return node;
}

private Node enq(final Node node) {
for (;;) {//自旋方式不断尝试插入队尾，直至成功为止
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}

（4）acquireQueued方法，主要是让加入队尾的线程进入等待状态，等到前面的进程执行完了，再唤醒该线程，去执行同步代码在这里是检测是否应该park()（park是一个Unsafe包中的native方法），以及检测在队列的等待过程中是否有中断，在等待过程中是不响应中断的，等到等待结束被唤醒时，才去向上传递是否中断过的值。

final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {//自旋
final Node p = node.predecessor();//获取前驱节点
if (p == head && tryAcquire(arg)) {//若前驱节点是头节点，便可以尝试去获取资源，若获取到资源，则进行下面的队列修改
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) && //检测是否需要等待及找到一个前驱未放弃的节点，连接在后面
parkAndCheckInterrupt()) //等待，并且等到等待结束，返回是否被中断过
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}

流程图：
2、释放资源的过程
（1）release方法public final boolean release(int arg) {
if (tryRelease(arg)) {//尝试释放资源，一般不会失败，state加一
Node h = head;
if (h != null && h.waitStatus != 0)//
unparkSuccessor(h);//唤醒等待队列里的下一个线程
return true;
}
return false;
}（2）tryRelease方法，同样需要自己重写protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}