AbstractQueuedSynchronizer 详解
欢迎光临我的博客[http://poetize.cn]，前端使用Vue2，聊天室使用Vue3，后台使用Spring Boot
package java.util.concurrent.locks;
基本介绍
AbstractQueuedSynchronizer（队列同步器）可以看作是并发包（java.util.concurrent）的基础框架：
JDK中许多并发工具类的内部实现都依赖于AQS，如ReentrantLock, Semaphore, CountDownLatch等。
AQS底层依靠CAS与同步队列。
AbstractQueuedSynchronizer会把请求获取锁失败的线程放入一个队列的尾部：
等待获取锁的线程全部处于阻塞状态。当前线程执行完毕（释放锁）后，会激活当前线程的后继节点。
公平锁和非公平锁
ReentranLock分为公平锁和非公平锁，二者的区别就在获取锁机会是否和排队顺序相关：
如果锁被另一个线程持有，那么申请锁的其他线程会被挂起等待，加入等待队列。
理论上，先调用lock()函数被挂起等待的线程应该排在等待队列的前端，后调用的就排在后边。
如果此时，锁被释放，需要通知等待线程再次尝试获取锁：
ReentranLock公平锁会让最先进入队列的线程获得锁。
ReentranLock非公平锁则会让当前正在请求的线程插队获取锁，获取失败则放在队尾排队等待。
模板模式
AQS是一个抽象类，当构建一个同步组件的时候，需要定义一个子类继承AQS，应用了模板方法设计模式。
模板模式由一个抽象类和一个实现类组成，抽象类中主要有三类方法：
模板方法：实现了算法主体框架，供外部调用。里面会调用原语操作和钩子操作。
原语操作：即定义的抽象方法，子类必须重写。
钩子操作：和原语操作类似，也是供子类重写的，
区别是钩子操作子类可以选择重写也可以选择不重写，如果不重写则使用抽象类默认操作，通常是一个空操作或抛出异常。
AQS中可供子类重写的钩子操作
| 方法名称 | 描述 |
|---|---|
| boolean tryAcquire(int arg) | 独占式获取同步状态，成功返回true，失败返回false |
| boolean tryRelease(int arg) | 独占式释放同步状态，成功返回true，失败返回false |
| int tryAcquireShared(int arg) | 共享式获取同步状态，获取成功则返回值>=0 |
| boolean tryReleaseShared(int arg) | 共享式释放同步状态，成功返回true，失败返回false |
| boolean isHeldExclusively() | 判断同步器是否在独占模式下被占用，一般用来表示同步器是否被当前线程占用 |
模板方法
子类重写相关钩子操作后，AQS中提供的模板方法才能正常调用。
| 方法 | 描述 |
|---|---|
| void acquire(int arg) | 独占式获取同步状态，该方法会调用子类重写的tryAcquire(int arg)，如果tryAcquire返回true则该方法直接返回，否则先将当前线程加入同步队列的尾部，然后阻塞当前线程 |
| void acquireInterruptibly(int arg) | 当线程获取同步状态失败被阻塞后，可以响应中断，收到中断后将会取消获取同步状态 |
| boolean tryAcquireNanos(int arg, long nanosTimeout) | 在acquireInterruptibly的基础上加了超时限制，如果在超时时间内获取到同步状态返回true，否则返回false |
| boolean release(int arg) | 独占式释放同步状态，该方法会在释放同步状态后将第一个节点（对应刚刚释放同步状态的线程）的后继节点对应的线程唤醒。 |
| void acquireShared(int arg) | 共享式获取同步状态，该方法会调用子类重写的tryAcquireShared(int arg)，如果tryAcquireShared返回true则该方法直接返回，否则先将当前线程加入同步队列的尾部，然后阻塞当前线程 |
| void acquireSharedInterruptibly(int arg) | 当线程获取同步状态失败被阻塞后，可以响应中断，收到中断后将会取消获取同步状态 |
| boolean tryAcquireSharedNanos(int arg, long nanosTimeout) | 在acquireSharedInterruptibly的基础上加了超时限制，如果在超时时间内获取到同步状态返回true，否则返回false |
| boolean releaseShared(int arg) | 共享式的释放同步状态 |
源码分析
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
static final class Node {
static final int CANCELLED = 1; //当前节点被取消。
static final int SIGNAL = -1; //表示当前节点的的后继节点将要或者已经被阻塞，在当前节点释放的时候需要unpark（唤醒）后继节点。
static final int CONDITION = -2; //表示当前节点在等待condition，即在condition队列中。
static final int PROPAGATE = -3; //表示releaseShared需要被传播给后续节点（仅在共享模式下使用）。
//等待状态（默认0：无状态，表示当前节点在队列中等待获取锁。）
volatile int waitStatus;
volatile Node prev;
volatile Node next;
//当前节点代表的线程
volatile Thread thread;
Node nextWaiter;
Node() {}
Node(Node nextWaiter) {
this.nextWaiter = nextWaiter;
THREAD.set(this, Thread.currentThread());
}
Node(int waitStatus) {
WAITSTATUS.set(this, waitStatus);
THREAD.set(this, Thread.currentThread());
}
}
private transient volatile Node head;
private transient volatile Node tail;
//独占变量state（通过CAS和volatile保证了线程安全问题）
//state的值表示其状态：如果是0，那么当前还没有线程独占此变量；否在就是已经有线程独占了这个变量，也就是代表已经有线程获得了锁。
private volatile int state;
private void setHead(Node node) {
head = node;
node.thread = null; //防止内存泄漏
node.prev = null;
}
public final void acquire(int arg) {
//尝试获取锁（AQS在无竞争条件下，不会new出head和tail节点。），失败则自旋，阻塞当前线程，重新获取锁，直到获取锁成功
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //Node.EXCLUSIVE：标记指示节点在独占模式下等待
selfInterrupt();
}
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
//ReentrantLock实现的公平锁
static final class FairSync extends Sync {
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
//获取AQS中的state变量
int c = getState();
//值为0，那么当前独占性变量还未被线程占有
if (c == 0) {
//自旋获取锁（在没有其他等待时间更长的线程时：!hasQueuedPredecessors()）
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
//将本线程设置为独占性变量所有者线程
setExclusiveOwnerThread(current);
return true;
}
}
//如果该线程已经获取了锁，那么根据重入性原理，将state值进行加1，表示多次lock
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
//通过调用addWaiter函数，AQS将当前线程加入到了等待队列尾部，但是还没有阻塞当前线程的执行
private Node addWaiter(Node mode) {
Node node = new Node(mode);
//自旋，直到插入成功
for (;;) {
Node oldTail = tail;
if (oldTail != null) {
node.setPrevRelaxed(oldTail);
if (compareAndSetTail(oldTail, node)) {
oldTail.next = node;
return node;
}
} else {
initializeSyncQueue(); //如果没有头尾节点，建立空节点，并赋值给头尾节点
}
}
}
//获取锁失败，则插入队尾，并自旋，阻塞线程，重新获取锁
//队列中的线程获取锁的条件（公平锁）：上一个节点是头节点，并且成功tryAcquire(arg)
final boolean acquireQueued(final Node node, int arg) {
boolean interrupted = false;
try {
//如果当前线程成功获取锁，则将当前线程设置为头节点，否则一直自旋
for (;;) {
//返回上一个节点，如果为空，则抛出nullpointerexception
final Node p = node.predecessor();
//如果上一个节点是头结点，并且当前线程获取到锁，将当前结点设置为头结点，并返回
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node)) //将当前线程节点的prev指向有效节点
interrupted |= parkAndCheckInterrupt(); //阻塞线程
}
} catch (Throwable t) {
cancelAcquire(node);
if (interrupted)
selfInterrupt();
throw t;
}
}
public final boolean release(int arg) {
//尝试释放锁
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
//唤醒head节点的其他节点
unparkSuccessor(h);
return true;
}
return false;
}
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
//ReentrantLock实现的公平锁
abstract static class Sync extends AbstractQueuedSynchronizer {
//释放独占性变量，就是将status的值减1（0：完全释放锁）
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;
}
}
//释放锁后需要唤醒其他线程
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
node.compareAndSetWaitStatus(ws, 0);
Node s = node.next;
//判断head节点的next节点是否为空或者是否是取消状态：如果是，则找其他节点。
if (s == null || s.waitStatus > 0) {
s = null;
//从队列尾部向前遍历找到最前面的一个waitStatus<=0的节点
for (Node p = tail; p != node && p != null; p = p.prev)
if (p.waitStatus <= 0)
s = p;
}
if (s != null)
//唤醒找到的节点线程
LockSupport.unpark(s.thread);
}
}
