1 什么是AQS
AQS,即AbstractQueuedSynchronizer,是用来构建锁或者其他同步组件的基础框架。在JSR166
(java规范提案)中提出并创建。有以下特点:
- 用int state 属性来表示资源的状态,子类需要定义如何维护这个状态,控制获取锁和释放锁;
- 提供了基于 FIFO 的等待队列,类似 Monitor的 EntryList;
- 条件变量来实现等待、唤醒机制,支持多个条件变量,类似于Monitor的 WaitSet。
AQS是一个抽象类,主要通过继承来使用,子类实现它的抽象方法来管理同步状态。AQS自身没有实现任何同步接口,仅是定义了若干同步状态获取和释放的方法。ReentrantLock、ReentrantReadWriteLock和CountDownLatch等,都是基于它实现的。
2 两种模式
在使用中,AQS有两种模式:独占式和共享式
- 独占式,就是在同一时刻最多只有一个线程获取到锁,而其他获取锁的线程只能 处于同步队列中等待,直到获取锁的线程释放了锁。ReentrantLock就是独占式锁;
- 共享式,允许多个线程同时获取到锁,并发访问共享资源,比如ReentrantReadWriteLock。
3 要点
- 原子维护 state 状态:使用 volatile 配合 cas 保证其修改时的原子性、可见性、有序性
- 阻塞及恢复线程:使用 park & unpark来实现线程的暂停和恢复
- 维护队列:使用CLH队列,是一个 FIFO的双向链表列。
4 方法
整理了一份核心面试笔记包括了:Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题
需要全套面试笔记的【点击此处即可】即可免费获取
AQS的子类,应当重写以下方法。
方法 | 描述 |
---|---|
protected boolean tryAcquire(int arg) | 独占式获取同步状态 |
protected boolean tryRelease(int arg) | 独占式释放同步状态 |
protected int tryAcquireShared(int arg) | 共享式获取同步状态 |
protected boolean tryReleaseShared(int arg) | 共享式释放同步状态 |
protected boolean isHeldExclusively() | 同步状态是否被当前线程所独占 |
AQS提供了这些模板方法,模板方法将调用上面子类重写后的方法。
java
代码解读
复制代码
// 独占式获取同步状态 public final void acquire(int arg) // 与acquire(int arg)相同,但该方法响应中断 public final void acquireInterruptibly(int arg) throws InterruptedException // 在acquireInterruptibly(int arg)基础上增加了超时限制 public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException // 共享式获取同步状态,同一时刻可以有多个线程获得同步状态。 public final void acquireShared(int arg) // 与acquireShared(int arg)相同,但该方法响应中断 public final void acquireSharedInterruptibly(int arg) throws InterruptedException // 在acquireSharedInterruptibly(int arg)基础上,增加了超时限制 public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException // 独占式的释放同步状态 public final boolean release(int arg) // 共享式的释放同步状态 public final boolean releaseShared(int arg) // 获取在同步队列中等待的线程集合 public final Collection<Thread> getQueuedThreads()
5 CLH队列
- CLH队列是一个FIFO的双向链表:由head、tail、node中间节点组成,每个Node节点包含:thread、waitStatus、next、pre属性。
- 插入链表都是尾部插入并且setTail为当前节点,同时会阻塞当前线程(调用LockSupport.park方法);
- 当线程释放同步状态后,会唤醒head节点的next节点,next节点会抢占同步资源,抢占失败后重新阻塞;成功后将next节点setHead。
使用CLH队列的目的在于:
- 同步器持有队列的head、tail节点,能快速出队、入队,不用遍历链表;
- 持有同步资源的线程执行完毕,只会唤醒head节点的next节点,队列中其他节点持续阻塞;这样只有next节点和新到来线程抢占资源,避免不必要的自旋竞争;
通过Unsafe的CAS操作来更新同步器的head、tail引用
6 线程入队
6.1 acquire方法实现
- 当线程
tryAcquire(arg)
失败时,被包装为一个Node节点(称为newNode)。 - CAS更新tail引用为newNode失败时,
enq(node)
方法中通过for (;;)
死循环重试,直到入队成功。 - 入队成功后,如果newNode的prev节点是head节点,即newNode有资格抢占同步资源,则尝试获取一次;成功时,更新head引用为newNode,退出;
- 失败时,等prev节点的
waitStatus==SIGNAL
时,将newNode park阻塞,直到被其他线程unpark或interrupt时,继续for循环;
6.2 入队流程图示
如图,AQS刚初始化时,head、tail都是null。
当添加nodo1时,首先创建一个哑元,head、tail都指向它。然后将nodo1加到队尾。
acquire(int arg)
方法调用流程如下图。
7 线程出队
出队,即唤醒head节点的next节点,next节点争抢同步资源成功时,更新head引用为自己。
7.1 release实现
注意,release(int arg)
是exclusive mode
下释放资源,同步锁只能由一个线程获得,不会被并发调用。因此不需要for循环+CAS。流程如下:
- 首先,head节点是获取同步状态成功的节点,
release(int arg)
就是head节点的线程来唯一调用。 - 其次,更新head节点引用,是由被唤醒线程在
acquireQueued()
中通过for (;;)加CAS来实现。 - 如果head的next节点被cancel了,则从tail向前遍历,找到一个入队最早且状态满足的node,来唤醒它。
unparkSuccessor
中没有失败重试
7.2 releaseShared实现
releaseShared
是shared mode
下释放资源,存在多线程并发。因此使用了for循环+CAS重试。
doReleaseShared()
中,可以看到不断重试。
8 acquire与acquireInterruptibly的区别
两者区别在于:
- 线程调用acquire()获取同步资源阻塞时,即使被interrupt,也必须等到获取资源成功后,才能调用
selfInterrupt()
; - 线程调用acquireInterruptibly()时,在park状态被interrupt,将抛出
InterruptedException
而退出for循序;不用等到获取资源成功。
可见,线程调用acquire()时,如何处理中断(忽略继续或其他)在于自身;调用acquireInterruptibly()时被中断,将得到InterruptedException
异常。
9 自定义独占式锁
基于AQS,我们能非常方便地实现一个自定义的独占锁:与ReentrantLock相比,MyExclusiveLock只是不支持锁重入、不支持公平模式,其他并无多少区别。
java
代码解读
复制代码
import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.AbstractQueuedSynchronizer; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; public class MyExclusiveLock implements Lock { // 将对Lock的操作转交给Sync private final Sync sync = new Sync(); // AQS子类,独占模式 private static final class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = -4847038481668784725L; @Override protected boolean tryAcquire(int arg) { if (compareAndSetState(0, 1)) { setExclusiveOwnerThread(Thread.currentThread()); return true; } return false; } @Override protected boolean tryRelease(int arg) { setExclusiveOwnerThread(null); setState(0); return true; } @Override protected boolean isHeldExclusively() { return getState() == 1; } public Condition newCondition() { return new ConditionObject(); } } @Override public void lock() { sync.acquire(1); } @Override public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1); } /** * 尝试一次加锁 * * @return 成功否 */ @Override public boolean tryLock() { return sync.tryAcquire(1); } @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { return sync.tryAcquireNanos(1, unit.toNanos(time)); } @Override public void unlock() { sync.release(1); } @Override public Condition newCondition() { return sync.newCondition(); } }