一、什么是AQS
1. AQS的定义
AQS 的全称为 AbstractQueuedSynchronizer ,中文译为抽象队列式同步器。这个类在 java.util.concurrent.locks 包下面。这个抽象类对于JUC并发包非常重要,JUC包中的 ReentrantLock,Semaphore,ReentrantReadWriteLock,CountDownLatch 等等几乎所有的类都是基于AQS实现的。
2. AQS的原理/思想
如果被请求的共享资源空闲,则将当前请求资源的线程设置为有效的工作线程,并将共享资源设置为锁定状态,如果被请求的共享资源被占用,那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制,这个机制AQS是用CLH队列锁实现的,即将暂时获取不到锁的线程加入到队列中。
队列:AQS其实就是基于 CLH队列 产生的,这个队列是一个双向队列,不存在队列示例,仅存在节点之间的关系。用 volatile 关键字来修饰其中的变量 state,线程利用 CAS 去改变这个值,改变成功则表示获取成功,否则就是获取失败,进入等待队列等待被唤醒。
tips:AQS是自旋锁,等待唤醒的时候会不断自旋尝试获取锁,直到锁被获取或被其他线程获取
AQS的实现方式如下:
AQS使用 private volatile int state 表示同步状态。通过内置的FIFO队列完成线程的排队。使用CAS对state进行修改。。
二、节点
第一节里我们提到 —— AQS 是基于 CLH 队列产生的,这个队列是一个虚拟的双向队列。这一节我们来看看这个队列里的节点。
在 AbstractQueuedSynchronizer 源码中,作者编写了 等待队列节点类,并赋予了类的解释:
等待队列是“CLH”(Craig、Landin和Hagersten)锁队列的变体。CLH锁通常用于旋转锁。相反,我们使用它们来阻止同步器,但使用相同的基本策略,即在其节点的前一个线程中保存一些关于该线程的控制信息。每个节点中的“状态”字段跟踪线程是否应该阻塞。当一个节点的前一个节点释放时,它会收到信号。队列的每个节点都充当一个特定的通知样式监视器,其中包含一个等待线程。
机器翻译读起来怪怪的,那就直接看这个类是什么样子吧:
static final class Node {
static final Node SHARED = new Node();
static final Node EXCLUSIVE = null;
// 队列中节点状态值 也就是 waitStatus
static final int CANCELLED = 1;
static final int SIGNAL = -1;
static final int CONDITION = -2;
static final int PROPAGATE = -3;
// 队列中节点状态
volatile int waitStatus;
// 前驱、后继
volatile Node prev;
volatile Node next;
volatile Thread thread;
Node nextWaiter;
final boolean isShared() {
return nextWaiter == SHARED;
}
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
Node() { // Used to establish initial head or SHARED marker
}
Node(Thread thread, Node mode) { // Used by addWaiter
this.nextWaiter = mode;
this.thread = thread;
}
Node(Thread thread, int waitStatus) { // Used by Condition
this.waitStatus = waitStatus;
this.thread = thread;
}
}
以及最重要的成员:
private volatile int state;
线程获取或释放锁的本质是去修改AQS里的 state。比如说,我们创建一个ReentrantLock的实例,此时该锁实例内部的state为0,表征它还没有被任何线程所持有。当多个线程同时调用它的lock()方法获取锁时,它们的本质操作其实就是将该锁实例的state值由0修改为1,第1个抢到这个操作执行的线程就成功获取了锁,后续执行操作的线程就会看到state值已经为1了,即表明该锁已经被其他线程获取,它们抢占锁失败了。这些抢占锁失败的线程会被AQS放入到CHL队列里面去维护起来。
三、实现AQS
AQS支持线程抢占两种锁——独占锁和共享锁:
独占锁:同一个时刻只能被一个线程占有,如ReentrantLock,ReentrantWriteLock等,它又可分为:
公平锁:按照线程在队列中的排队顺序,先到者先拿到锁
非公平锁:当线程要获取锁时,无视队列顺序直接去抢锁,谁抢到就是谁的
共享锁:同一时间点可以被多个线程同时占有,如ReentrantReadLock,Semaphore等
AQS的所有子类中,要么使用了它的独占锁,要么使用了它的共享锁,不会同时使用它的两个锁。
在 AQS 的源码里,作者是这么说的:
要将此类用作同步器的基础,请通过使用getState、setState和/或compareAndSetState检查和/或修改同步状态,重新定义以下方法(如适用):
tryAcquire
tryRelease
tryAcquireShared
tryReleaseShared
isHeldExclusively
//独占锁的获取锁与释放锁
//返回值表示获取锁是否成功
protected boolean tryAcquire(int arg){}
//返回值表示释放锁是否成功
protected boolean tryRelease(int arg){}
//共享锁的获取锁与释放锁
//返回值表示获得锁后还剩余的许可数量
protected int tryAcquireShared(int arg){}
//返回值表示释放锁是否成功
protected boolean tryReleaseShared(int arg){}
//调用该方法的线程是否持有独占锁,一般用到了condition的时候才需要实现此方法
protected boolean isHeldExclusively(){}
这些方法是子类需要实现的,可以选择实现其中的一部分。根据实现方式的不同,可以分为两种:独占锁和共享锁。
独占锁需要实现的是 tryAcquire(int)、tryRelease(int)
共享锁需要实现的是 tryAcquireShared(int)、tryReleaseShared(int)
以ReentrantLock为例:state初始化为0,表示未锁定状态,A线程lock()时,会调用tryAcquire()独占锁并将state+1.之后其他线程再想tryAcquire的时候就会失败,直到A线程unlock()到state=0为止,其他线程才有机会获取该锁。A释放锁之前,自己也是可以重复获取此锁(state累加),这就是可重入的概念。
注意:获取多少次锁就要释放多少次锁,保证state是能回到零态的。
以CountDownLatch为例,任务分N个子线程去执行,state就初始化为N,N个线程并行执行,每个线程执行完之后countDown()一次,state就会CAS减一。当N子线程全部执行完毕,state=0,会unpark()主调用线程,主调用线程就会从await()函数返回,继续之后的动作。
1. ReentrantLock
ReentrantLock 默认采用非公平锁,因为考虑获得更好的性能,通过 boolean 来决定是否用公平锁(传入 true 用公平锁)。
private final Sync sync;
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
// 非公平锁的实现
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
final void lock() {
// 尝试直接获取锁
if (compareAndSetState(0, 1))
// 获取到了直接返回
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
// nonfairTryAcquire 方法
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 非公平锁不判断阻塞队列的状态
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
// 公平锁的实现
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
//
int c = getState();
if (c == 0) {
// 公平锁先判断阻塞队列的状态
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
公平锁和非公平锁的不同:
- 非公平锁在调用 lock 之后,会直接调用 CAS 进行抢锁,如果此时锁未被占用,则直接获得锁并返回。
- 非公平锁 CAS 抢锁失败后,和公平锁一样都会通过 acquire(1) 进入到 tryAcquire 方法。在这个方法中,如果发现锁被释放了,也就是 state = 0,非公平锁会直接尝试 CAS 抢锁,公平锁会判断是否有线程处于等待状态,如果有则自行排到队列后等待唤醒。
2. CountDownLatch
CountDownLatch允许一个或者多个线程去等待其他线程完成操作。需要实现的是 tryAcquireShared(int)、tryReleaseShared(int)
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
3. Mutex
本质上都是实现 tryAcquire(int)、tryRelease(int) 或者 tryAcquireShared(int)、tryReleaseShared(int)
class Mutex implements Lock, java.io.Serializable {
// Our internal helper class
private static class Sync extends AbstractQueuedSynchronizer {
// Reports whether in locked state
protected boolean isHeldExclusively() {
return getState() == 1;
}
// Acquires the lock if state is zero
public boolean tryAcquire(int acquires) {
assert acquires == 1; // Otherwise unused
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// Releases the lock by setting state to zero
protected boolean tryRelease(int releases) {
assert releases == 1; // Otherwise unused
if (getState() == 0) throw new IllegalMonitorStateException();
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// Provides a Condition
Condition newCondition() {
return new ConditionObject();
}
// Deserializes properly
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
}