一、什么是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
}
}
}
扫一扫
655
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
