目录
- [1. 是什么](#1. 是什么)
- [2. 如何使用](#2. 如何使用)
- [3. 原理分析](#3. 原理分析)
- [3.1. 构造方法](#3.1. 构造方法)
- [3.1.1. 由头尾节点和代表锁状态的字段组成](#3.1.1. 由头尾节点和代表锁状态的字段组成)
- [3.1.2. Node是个双向队列节点](#3.1.2. Node是个双向队列节点)
- [3.2. 获取锁的逻辑](#3.2. 获取锁的逻辑)
- [3.2.1. 尝试获取锁](#3.2.1. 尝试获取锁)
- [3.2.2. 尝试获取锁失败,则加入AQS队列](#3.2.2. 尝试获取锁失败,则加入AQS队列)
- [3.2.3. 阻塞等待,被唤醒后不停得抢占锁](#3.2.3. 阻塞等待,被唤醒后不停得抢占锁)
- [3.2.3.1. 判断是否需要阻塞当前线程](#3.2.3.1. 判断是否需要阻塞当前线程)
- [3.2.3.2. 阻塞当前线程](#3.2.3.2. 阻塞当前线程)
- [3.2.3.3. 抢占锁过程中发生异常,那么从阻塞队列中移除当前节点](#3.2.3.3. 抢占锁过程中发生异常,那么从阻塞队列中移除当前节点)
- [3.2.4. 恢复中断标记](#3.2.4. 恢复中断标记)
- [3.3. 释放锁的逻辑](#3.3. 释放锁的逻辑)
- [3.3.1. 尝试释放锁](#3.3.1. 尝试释放锁)
- [3.3.2. 释放锁成功则唤醒下一个节点的线程,让其继续抢占锁](#3.3.2. 释放锁成功则唤醒下一个节点的线程,让其继续抢占锁)
- [3.1. 构造方法](#3.1. 构造方法)
- [4. 总结](#4. 总结)
- [5. 参考](#5. 参考)
1. 是什么
队列同步器,用于实现JUC包的其他并发工具类
2. 如何使用
一般我们不直接使用AQS,而是使用JUC中的其他工具类(如CountDownLatch等),这些工具类覆盖了几乎所有的使用场景,只有在这些工具类无法满足我们的需求时,才去用AQS实现自己的并发工具。
实现的一般的套路如下:
- 定义并发工具类
- 在并发工具类内部定义一个静态内部类,实现AQS,根据需要重写一些方法
- 并发工具类中定义对外的方法,具体实现调用内部静态类的方法进行处理
如下代码为我们实现的简单的CountDownLatch
java
public class BooleanLatch
{
//定义内部静态类继承AQS
//重写对state操作的方法
private static class Sync extends AbstractQueuedSynchronizer
{
boolean isSignalled()
{
return getState() != 0;
}
protected int tryAcquireShared(int ignore)
{
return isSignalled() ? 1 : -1;
}
protected boolean tryReleaseShared(int ignore)
{
setState(1);
return true;
}
}
//对外暴露的是封装后的方法
private final Sync sync = new Sync();
public boolean isSignalled()
{
return sync.isSignalled();
}
public void signal()
{
sync.releaseShared(1);
}
public void await() throws InterruptedException
{
sync.acquireSharedInterruptibly(1);
}
public static void main(String[] args) throws InterruptedException
{
BooleanLatch booleanLatch = new BooleanLatch();
new Thread(()-> {
try
{
TimeUnit.SECONDS.sleep(60);
System.out.println(Thread.currentThread().getName() + "休眠结束");
booleanLatch.signal();
}
catch (Exception e)
{
e.printStackTrace();
}
}, "releaseThread").start();
booleanLatch.await();
System.out.println(Thread.currentThread().getName() + "继续运行");
}
}
3. 原理分析
可以先阅读手写AQS.md以便更好的理解AQS源码
3.1. 构造方法
3.1.1. 由头尾节点和代表锁状态的字段组成
java
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
protected AbstractQueuedSynchronizer() { }
//使用双向队列保存抢占锁失败的线程
private transient volatile Node head;
private transient volatile Node tail;
//使用CAS操作volatile state字段,表示锁的状态
//state > 0表示获取了锁,state = 0表示释放了锁
private volatile int state;
}
3.1.2. Node是个双向队列节点
java
static final class Node {
// 表示shared mode
static final Node SHARED = new Node();
// 表示exclusive mode
static final Node EXCLUSIVE = null;
//当前线程被取消
static final int CANCELLED = 1;
//下一个节点需要unpark
static final int SIGNAL = -1;
//Node的状态
volatile int waitStatus;
//前一个节点
volatile Node prev;
//后一个节点
volatile Node next;
//该节点关联的线程
volatile Thread thread;
//
Node nextWaiter;
// 用于在share mode下创建占位符的头节点
Node() {
}
// Used by addWaiter
Node(Thread thread, Node mode) {
this.nextWaiter = mode;
this.thread = thread;
}
}
结构如下图:
3.2. 获取锁的逻辑
java
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
如果tryAcquire返回True,那么表示得到了锁并且不用执行后面的逻辑,acquire直接返回,此时当前线程没有入队
3.2.1. 尝试获取锁
让我们看看tryAcquire的实现
java
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
what?居然就只是简单的抛出异常?其实这里运用了模板方法的设计模式,由子类决定具体实现,
如果tryAcquire返回False,便是没有获取锁,那么执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg))这段逻辑。
3.2.2. 尝试获取锁失败,则加入AQS队列
首先是addWaiter(Node.EXCLUSIVE),把当前线程以EXCLUSIVE构成node加入等待队列
java
private Node addWaiter(Node mode) {
//用当前线程、EXCLUSIVE模式构造节点
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
//队列中尾节点不为空(即不是空队列)
//那么插入mode到队尾
if (pred != null) {
//mode(新节点)的prev指针指向尾节点
node.prev = pred;
//cas设置mode为新的尾节点
if (compareAndSetTail(pred, node)) {
//设置成功则修改旧尾节点的next为mode
pred.next = node;
return node;
}
}
//队列为空或者插入到队尾失败
enq(node);
return node;
}
- 8-17行:快速尝试入队,如果队列中尾节点不为空(即不是空队列),则尝试把当前线程构造的节点加入队列的尾部
- 19行:队列为空或者快速尝试入队失败,那么调用enq。enq代码如下:
java
private Node enq(final Node node) {
for (;;) {
Node t = tail;
//队尾为空,说明队列为空需要初始化
if (t == null) { // Must initialize
//设置new Node为队头(这个头是个占位符)
if (compareAndSetHead(new Node()))
tail = head;
//队列不为空,加入队列尾部
//下面的逻辑跟addWaiter的快速尝试差不多
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
- 2行:一直尝试,直到入队成功为止
- 3-10:如果队列为空,那么使用CAS操作设置new Node为队列头节点(这个头节点是个占位符),接着回到2行for循环,继而执行下面的else逻辑
- 11-16:队列不为空,使用CAS操作把当前节点加入到队列尾部
CAS操作就是调用的是Unsafe类的方法,如下:
java
private final boolean compareAndSetTail(Node expect, Node update) {
//tail == expect?是的话更新tail为update
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
加入队尾成功后,接着执行acquireQueued方法
3.2.3. 阻塞等待,被唤醒后不停得抢占锁
java
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
//node就是addWaiter里加入到队尾的节点,p是node的前一个节点
final Node p = node.predecessor();
//逻辑1:
//p(前置节点)是head(占位符的头节点)的情况下才尝试获取锁。即当前节点前面没有人等待获取锁,换句话说当前节点就是实际的队头或者说等待时间最长的节点
if (p == head && tryAcquire(arg)) {
//尝试获取锁成功后设置占位符头节点为node(当前节点)
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//逻辑2:
//执行到这里说明上面的获取锁的条件不满足或者抢占锁失败
//那么需要判断是否需要阻塞,需要的话则进行阻塞
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
//何时执行这段逻辑?发生异常导致获取锁失败的时候
cancelAcquire(node);
}
}
- 5行:死循环尝试直到获取锁成功
- 6-17行:如果刚刚使用addWaiter入队尾的当前节点前面没有其他节点在等待,即我是等待时间最长的节点,那么尝试抢占锁。这里之所以还需要抢占是因为可以有其他线程(不是队列中的线程)同时进来抢占锁
- 18-23行:抢占锁失败则需要阻塞。阻塞后什么时候被唤醒?当前节点(当前线程)的前序节点释放同步状态时,会唤醒该节点(该线程)(unparkSuccessor)。唤醒之后干什么?继续执行上面的逻辑1
3.2.3.1. 判断是否需要阻塞当前线程
- shouldParkAfterFailedAcquire
java
//根据(前一个节点,当前节点)->是否阻塞当前线程
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
//如果当前节点的前一个节点状态为SIGNAL
//表示它(前一个节点)承诺唤醒当前节点,那么可以放心阻塞,故直接返回ture
if (ws == Node.SIGNAL)
return true;
//>0表示状态为取消的节点
//前置节点已被取消
if (ws > 0) {
//一直往前遍历找到没有取消的节点,并且遍历过程中把取消的节点删除
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
//前置节点未被取消(即为 0 或者 Node.PROPAGATE)
} else {
//CAS设置前置节点状态为SIGNAL,下次进来就是5-6行
//pred的waitStatus==ws?是的话更新waitStatus为Node.SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
- 6-7行:当前节点的前置节点状态为SIGNAL的时候,可以阻塞
3.2.3.2. 阻塞当前线程
- parkAndCheckInterrupt
java
private final boolean parkAndCheckInterrupt() {
//简单的调用LockSupport的park方法阻塞当前线程
LockSupport.park(this);
//返回是否被中断的标志
return Thread.interrupted();
}
- LockSupport park
java
public static void park(Object blocker) {
Thread t = Thread.currentThread();
//用当前AQS实例对象作为blocker,记录当前线程等待的对象(阻塞对象)
setBlocker(t, blocker);
//简单调用UNSAFE的park方法阻塞当前线程
UNSAFE.park(false, 0L);
setBlocker(t, null);
}
3.2.3.3. 抢占锁过程中发生异常,那么从阻塞队列中移除当前节点
- cancelAcquire
java
//node是addWaiter加入队尾的节点
//这段取消的逻辑要做的就是从队列中删除该节点
private void cancelAcquire(Node node) {
// 当前节点为空,那么不需要删除,直接返回
if (node == null)
return;
//1. node不再关联到任何线程
node.thread = null;
//2. 找到前置节点
//跳过被cancel的前继node,往前找到一个有效的前继节点pred
Node pred = node.prev;
while (pred.waitStatus > 0) //>0表示状态为取消的节点
node.prev = pred = pred.prev;//限制性pred=pred.prev;在执行node.prev=pred
//predNext是前置节点的下一个节点,注意这里可能不是当前node
Node predNext = pred.next;
//3. 将node的waitStatus置为CANCELLED
node.waitStatus = Node.CANCELLED;
//4. 从队列中删除该节点
//当前node是尾节点的删除操作:CAS设置队列的尾节点为pred
if (node == tail && compareAndSetTail(node, pred)) {
//CAS设置pred.next为null
compareAndSetNext(pred, predNext, null);
//当前node不是尾节点的删除操作
} else {
int ws;
//5. 下面的判断是指node既不是tail,又不是head的后继节点的情况
//当前节点的前置节点不是队头
//并且
//要么 前置节点的状态为Node.SIGNAL(即承诺唤醒下一个节点)
//要么 前置节点的状态是正常的且CAS设置前置节点的状态为Node.SIGNAL成功 且
//前置节点的线程为null
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
//使node的前继节点的next指向node的后继节点,相当于删除了node
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
//6. 如果node是head的后继节点,则直接唤醒node的后继节点就行
} else {
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
3.2.4. 恢复中断标记
如果acquireQueued返回true,说明发生过中断。
但是呢,acquireQueued会把中断标记清除,因此需要手动调用selfInterrupt恢复中断标记
java
static void selfInterrupt() {
Thread.currentThread().interrupt();
}
3.3. 释放锁的逻辑
java
public final boolean release(int arg) {
//释放同步状态成功
if (tryRelease(arg)) {
//把头节点从队列中移除
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
解锁的逻辑主要是:
- 2行:尝试释放锁
- 3-5行:释放锁成功则唤醒下一个节点的线程,让其继续抢占锁
详细说明如下:
3.3.1. 尝试释放锁
- tryRelease,和tryAcquire方法一样延迟到子类实现
java
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
3.3.2. 释放锁成功则唤醒下一个节点的线程,让其继续抢占锁
- 如果头节点不为null,那么调用unparkSuccessor方法唤醒下一个节点
java
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
//如果当前节点的状态是正常的?
if (ws < 0)
//当前节点的状态<0,则把状态改为0
//0是空的状态,因为node这个节点的线程释放了锁后续不需要做任何
compareAndSetWaitStatus(node, ws, 0);
//获取当前节点的下一个节点
Node s = node.next;
//如果下一个节点是空(即当前节点是尾节点)或者下一个节点的状态>0(取消)
if (s == null || s.waitStatus > 0) {
s = null;
//从尾节点往前遍历至当前节点
for (Node t = tail; t != null && t != node; t = t.prev)
//找到最靠近当前节点的状态<=0(非取消)的节点
if (t.waitStatus <= 0)
s = t;
}
//唤醒当前节点的下一个节点
if (s != null)
LockSupport.unpark(s.thread);
}
- unpark方法
java
public static void unpark(Thread thread) {
if (thread != null)
//唤醒thread线程
UNSAFE.unpark(thread);
}
4. 总结
- thead1获取锁成功,执行业务逻辑
- thread2获取失败,进入CLH队尾,不停自旋检查
- 如果前一个节点的状态是signal,则进入阻塞;否则一直自旋直到获取锁成功
- thread1释放锁,唤醒下一个节点
- thead2从阻塞中醒来,获取锁成功,执行业务逻辑
5. 参考
- JUC的AQS学习-ReentrantLock源代码分析 | 并发编程网 -- ifeve.com
- Java AQS unparkSuccessor 方法中for循环从tail开始而不是head的疑问? - 知乎
- 【死磕 Java 并发】----- J.U.C 之 AQS:AQS 简介 | 芋道源码 ------ 纯源码解析博客
- 【死磕 Java 并发】----- J.U.C 之 AQS:CLH 同步队列 | 芋道源码 ------ 纯源码解析博客
- 【死磕 Java 并发】----- J.U.C 之 AQS:同步状态的获取与释放 | 芋道源码 ------ 纯源码解析博客
- 【死磕 Java 并发】----- J.U.C 之 AQS:阻塞和唤醒线程 | 芋道源码 ------ 纯源码解析博客