初识AQS
介绍AQS以前先认识下 LockSupport
一.LockSupport
JDK 中的 rt.jar包里面的 LockSupport是个工具类，它的主要作用是挂起和唤醒线程，该工具类是创建锁和其他同步类的基础。
LockSupport 类与每 个 使用它的线程都会关联一 个许可证，在 默认情况下调用 LockSupport 类的方法的线程是不持有许可证的。 LockSupport 是使用 Unsafe 类实现的， 下面介绍 LockSupport 中的几个主要函数
1.1void park()
如果调用 park 方法的线程已经拿到了与 LockSupport 关联的许可证 ，则 调用 Locksupport.park()时会马上返回，否则 阻 塞挂起。
public static void main(String[] args) {
System.out.println("come in");
LockSupport.park();//该方法会阻塞
System.out.println("over");
}
//结果
come in
有两种情况可以唤醒1.unpark() 2.interrupt() 方法。其他线程调用 了这两个方法 并且将当前线程作为参数时，调用park()方法而被阻塞的线程马上返回。
**跟interrupt相比较，因调用park()方法而被阻塞的线程被其他线程中断返回的是不会抛InterruptedException 异常。**
1.2 void unpark(Thread thread)方法
当一个线程调用unpark时候,如果参数thread是没有持有thread 与 LockSupport 类 关联的许可证， 则 让 thread 线程持有。 如果thread之前因调用pa rk()而被挂起，则调用unpack线程会被唤醒。如果thread之前没有掉prak,调用 unpark 方法后 ， 再 调用 park 方法，其会 立刻返 回
public static void main(String[] args) {
LockSupport.unpark(Thread.currentThread());
System.out.println("come in");
LockSupport.park();
System.out.println("over");
}
//输出
//come in
//over
1.3void park(Object blocker)
public static void park(Object blocker) {
Thread t = Thread.currentThread();//获取调用线程
setBlocker(t, blocker);//设置该线希呈的blocker变量
UNSAFE.park(false, 0L);//挂起线程
setBlocker(t, null);//线程被激活后清除blocker变量，因为 一般都是在线程阻塞时才分析原因
}
JDK 推荐我们使用带有 blocker 参 数的 park 方法，并且 blocker被设置为 this， 这样当在打印线程堆横排查问题时就能知道是哪个类被阻塞了。
二源码解析
AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。
AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，
AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。
AQS维护了一个volatile int state（代表共享资源）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。
AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。
AQS维护一个共享资源state，通过内置的FIFO来完成获取资源线程的排队工作。（这个内置的同步队列称为"CLH"队列）。该队列由一个一个的Node结点组成，每个Node结点维护一个prev引用和next引用，分别指向自己的前驱和后继结点。AQS维护两个指针，分别指向队列头部head和尾部tail。
Node结点
AQS在判断状态时，通过用waitStatus>0表示取消状态，而waitStatus<0表示有效状态。
/**在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消该Node的结点，其结点的waitStatus为CANCELLED，即结束状态，进入该状态后的结点将不会再变化 */
static final int CANCELLED = 1;
/** 被标识为该等待唤醒状态的后继结点，当其前继结点的线程释放了同步锁或被取消，将会通知该后继结点的线程执行。说白了，就是处于唤醒状态，只要前继结点释放锁，就会通知标识为SIGNAL状态的后继结点的线程执行 */
static final int SIGNAL = -1;
/** 与Condition相关，该标识的结点处于等待队列中，结点的线程等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁 */
static final int CONDITION = -2;
/**
* 与共享模式相关，在共享模式中，该状态标识结点的线程处于可运行状态
*/
static final int PROPAGATE = -3;
/**
等待状态，初始为0 代表初始化状态。
*/
volatile int waitStatus;
/**
当前结点的前驱结点
*/
volatile Node prev;
/**
当前结点的后继结点
*/
volatile Node next;
/**
与当前结点关联的排队中的线程
*/
volatile Thread thread;
2.1 acquire(int)
此方法是独占模式下线程获取共享资源的顶层入口。如果获取到资源，线程直接返回，否则进入等待队列，直到获取到资源为止，且整个过程忽略中断的影响
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
函数流程如下：
- tryAcquire()尝试直接去获取资源，如果成功则直接返回；
- addWaiter()将该线程加入等待队列的尾部，并标记为独占模式；
- acquireQueued()使线程在等待队列中获取资源，一直获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。
- 如果线程在等待过程中被中断过，它是不响应的，会继续执行。只是获取资源后才再进行自我中断selfInterrupt()，将中断状态补上，方便后续要对线程中断处理。
2.1.1 tryAcquire()
此方法尝试去获取独占资源。如果获取成功，则直接返回true，否则直接返回false。
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
概述里讲的AQS只是一个框架，具体资源的获取/释放方式交由自定义同步器去实现,至于能不能重入，能不能加塞，那就看具体的自定义同步器怎么去设计了
2.1.2 addWaiter(Node)
此方法用于将当前线程加入到等待队列的队尾，并返回当前线程所在的结点：
private Node addWaiter(Node mode) {
//mode有两种模式：EXCLUSIVE（独占）和SHARED（共享）
Node node = new Node(Thread.currentThread(), mode);
// 尝试快速方式直接放到队尾。
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//如果等待队列没有值，则通过enq放入
enq(node);
return node;
}
2.1.3 enq(Node)
此方法用于将node加入队尾。源码如下：
// CAS自旋volatile变量
private Node enq(final Node node) {
////CAS"自旋"，直到成功加入队尾
for (;;) {
Node t = tail;
if (t == null) { // 队列为空，创建一个空的标志结点作为head结点，并将tail也指向它。
if (compareAndSetHead(new Node()))
tail = head;
} else { //正常流程，放入队尾
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
2.1.4 acquireQueued(Node, int)
当前节点通过自旋来获取锁，如果获取锁失败就把waitStatus设置为-1，等待其他线程唤醒自己
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;////标记是否成功拿到资源
try {
boolean interrupted = false;//标记等待过程中是否被中断过
//又是一个“自旋”！
for (;;) {
final Node p = node.predecessor();//拿到前驱
//如果前驱是head，即该结点已成老二，那么便有资格去尝试获取资源（可能是老大释放完资源唤醒自己的，当然也可能被interrupt了）。
if (p == head && tryAcquire(arg)) {
setHead(node);//拿到资源后，将head指向该结点。所以head所指的标杆结点，就是当前获取到资源的那个结点或null。
p.next = null; // setHead中node.prev已置为null，此处再将head.next置为null，就是为了方便GC回收以前的head结点。也就意味着之前拿完资源的结点出队了！
failed = false;
return interrupted;//返回等待过程中是否被中断过
}
//如果自己可以休息了，就进入waiting状态，直到被unpark()
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;//如果等待过程中被中断过，哪怕只有那么一次，就将interrupted标记为true
}
} finally {
if (failed)
cancelAcquire(node);
}
}
线程被park进入挂起状态，这个时候只有unpark,interrupted才能被唤醒
2.1.5 shouldParkAfterFailedAcquire(Node, Node)
此方法判断当前获取锁失败后是否挂起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;//拿到前驱的状态
if (ws == Node.SIGNAL)
//如果已经告诉前驱拿完号后通知自己一下，那就可以安心休息了
return true;
if (ws > 0) {
/*
* 如果前驱放弃了，那就一直往前找，直到找到最近一个正常等待的状态，并排在它的后边。
* 注意：那些放弃的结点，由于被自己“加塞”到它们前边，它们相当于形成一个无引用链，稍后就会被保安大叔赶走了(GC回收)！
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//如果前驱正常，那就把前驱的状态设置成SIGNAL，告诉它拿完号后通知自己一下。有可能失败，人家说不定刚刚释放完呢！
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
整个流程中，如果前驱结点的状态不是SIGNAL，那么自己就不能安心去休息，需要去找个安心的休息点，同时可以再尝试下看有没有机会轮到自己拿号。
2.1.6parkAndCheckInterrupt()
线程进入挂起状态，执行Thread.interrupted()后会被清除中断标志。如果不清楚中断标记的话，下次循环再进来会无法挂起，导致死循环。一旦线程被中断标记过，当前线程会进入无限循环，所以这里必须要用Thread.interrupted()。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);//调用park()使线程进入waiting状态
return Thread.interrupted();//如果被唤醒，查看自己是不是被中断的。
}
park()会让当前线程进入waiting状态。在此状态下，有两种途径可以唤醒该线程：1）被unpark()；2）被interrupt()。需要注意的是，Thread.interrupted()会清除当前线程的中断标记位。
shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()总结
- 结点进入队尾后，检查状态，找到安全休息点；
- 调用park()进入waiting状态，等待unpark()或interrupt()唤醒自己；
- 被唤醒后，看自己是不是有资格能拿到号。如果拿到，head指向当前结点，并返回从入队到拿到号的整个过程中是否被中断过；如果没拿到，继续流程。
Demo 测试线程如果没有清除标记会不会会被挂起
for (int i = 0; i < 1; i++) {
Thread thread = new Thread(new Runnable() {
@Override public void run() {
for (; ; ) {
LockSupport.park(this);
System.out.println("xxxxxxxxxxxxxxxxxxxxxx");
System.out.println(Thread.interrupted());//Thread.interrupted()会清除中断标记，不清除中断标记会导致线程无法挂起，死循环
}
}
});
thread.start();
// LockSupport.unpark(thread);
thread.interrupt();
}
2.1.7acquireQueued()总结
- 调用自定义同步器的tryAcquire()尝试直接去获取资源，如果成功则直接返回；
- 没成功，则addWaiter()将该线程加入等待队列的尾部，并标记为独占模式；
- acquireQueued()使线程在等待队列中休息，有机会时（轮到自己，会被unpark()）会去尝试获取资源。获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。
- 如果线程在等待过程中被中断过，它是不响应的。只是获取资源后才再进行自我中断selfInterrupt()，将中断补上。
![[外链图片转存失败(img-FRFgKGDi-1568902297363)(C:\Users\yx20180503\AppData\Roaming\Typora\typora-user-images\1568788712902.png)]](https://i-blog.csdnimg.cn/blog_migrate/77fa67c53cc6b609f84ab60c0ef52c6f.png)
2.2释放同步状态–release()
此方法是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;//找到头结点
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);//唤醒等待队列里的下一个线程
return true;
}
return false;
}
它调用tryRelease()来释放资源。有一点需要注意的是，它是根据tryRelease()的返回值来判断该线程是否已经完成释放掉资源了！所以自定义同步器在设计tryRelease()的时候要明确这一点！！
5.2.2.1unparkSuccessor(Node)
private void unparkSuccessor(Node node) {
//这里，node一般为当前线程所在的结点。
int ws = node.waitStatus;
if (ws < 0)//置零当前线程所在的结点状态，允许失败。
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;//找到下一个需要唤醒的结点
if (s == null || s.waitStatus > 0) {//如果为空或已取消
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)//从这里可以看出，<=0的结点，都是还有效的结点。
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);//唤醒
}
一句话概括：用unpark()唤醒等待队列中最前边的那个未放弃线程，这里我们也用s来表示吧。此时，再和acquireQueued()联系起来，s被唤醒后，进入if (p == head && tryAcquire(arg))的判断（即使p!=head也没关系，它会再进入shouldParkAfterFailedAcquire()寻找一个安全点。这里既然s已经是等待队列中最前边的那个未放弃线程了，那么通过shouldParkAfterFailedAcquire()的调整，s也必然会跑到head的next结点，下一次自旋p==head就成立啦），然后s把自己设置成head标杆结点，表示自己已经获取到资源了，acquire()也返回了！
2.2.2小结
release()是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。
2.3acquireShared(int)
此方法是共享模式下线程获取共享资源的顶层入口。它会获取指定量的资源，获取成功则直接返回，获取失败则进入等待队列，直到获取到资源为止
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
这里 tryAcquireShared()依然需要自定义同步器去实现。但是AQS已经把其返回值的语义定义好了：负值代表获取失败；0代表获取成功，但没有剩余资源；正数表示获取成功，还有剩余资源，其他线程还可以去获取。所以这里acquireShared()的流程就是：
- tryAcquireShared()尝试获取资源，成功则直接返回；
- 失败则通过doAcquireShared()进入等待队列，直到获取到资源为止才返回。
2.3.1doAcquireShared(int)
此方法用于将当前线程加入等待队列尾部休息，直到其他线程释放资源唤醒自己，自己成功拿到相应量的资源后才返回。下面是doAcquireShared()的源码：
private void doAcquireShared(int arg) {
final Node node = addWaiter(Node.SHARED);//加入队列尾部
boolean failed = true;//是否成功标志
try {
boolean interrupted = false;//等待过程中是否被中断过的标志
for (;;) {
final Node p = node.predecessor();//前驱
if (p == head) {//如果到head的下一个，因为head是拿到资源的线程，此时node被唤醒，很可能是head用完资源来唤醒自己的
int r = tryAcquireShared(arg);//尝试获取资源
if (r >= 0) {
setHeadAndPropagate(node, r);//将head指向自己，还有剩余资源可以再唤醒之后的线程
p.next = null; // help GC
if (interrupted)//如果等待过程中被打断过，此时将中断补上
selfInterrupt();
failed = false;
return;
}
}
//判断状态，寻找安全点，进入waiting状态，等着被unpark()或interrupt()
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
2.3.2setHeadAndPropagate(Node, int)
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
setHead(node);//head指向自己
//如果还有剩余量，继续唤醒下一个邻居线程
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
此方法在setHead()的基础上多了一步，就是自己苏醒的同时，如果条件符合（比如还有剩余资源），还会去唤醒后继结点，毕竟是共享模式！
2.3.3小结
-
- tryAcquireShared()尝试获取资源，成功则直接返回；
- 失败则通过doAcquireShared()进入等待队列park()，直到被unpark()/interrupt()并成功获取到资源才返回。整个等待过程也是忽略中断的。
其实跟acquire()的流程大同小异，只不过多了个自己拿到资源后，还会去唤醒后继队友的操作（这才是共享嘛）。
2.4releaseShared()
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {//尝试释放资源
doReleaseShared();//唤醒后继结点
return true;
}
return false;
}
此方法的流程也比较简单，一句话：释放掉资源后，唤醒后继。跟独占模式下的release()相似，但有一点稍微需要注意：独占模式下的tryRelease()在完全释放掉资源（state=0）后，才会返回true去唤醒其他线程，这主要是基于独占下可重入的考量；而共享模式下的releaseShared()则没有这种要求，共享模式实质就是控制一定量的线程并发执行，那么拥有资源的线程在释放掉部分资源时就可以唤醒后继等待结点。例如，资源总量是13，A（5）和B（7）分别获取到资源并发运行，C（4）来时只剩1个资源就需要等待。A在运行过程中释放掉2个资源量，然后tryReleaseShared(2)返回true唤醒C，C一看只有3个仍不够继续等待；随后B又释放2个，tryReleaseShared(2)返回true唤醒C，C一看有5个够自己用了，然后C就可以跟A和B一起运行。而ReentrantReadWriteLock读锁的tryReleaseShared()只有在完全释放掉资源（state=0）才返回true，所以自定义同步器可以根据需要决定tryReleaseShared()的返回值。
2.4.1doReleaseShared()
此方法主要用于唤醒后继。
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);//唤醒后继
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // head发生变化
break;
}
}
参考：
https://javadoop.com/2017/07/20/AbstractQueuedSynchronizer
https://www.cnblogs.com/waterystone/p/4920797.html
扫一扫
428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
