在并发编程中AQS属于必知必会的内容了。AQS全称 AbstractQueuedSynchronizer抽象队列同步器。"抽象"就可以看出他是一个抽象类,我们在用时需要对他进行重写来自定义我们自己的同步器。
看懂这个源码个人认为需要一点链表操作的基础,不然容易晕。
类结构图
图简单解析
ReentrantLock 锁内部:
1、Sync类是ReentrantLock的内部类,其继承了AQS
2、FairSync和NonFairSync也是ReentrantLock的内部类,继承了Sync,
3、FairSync实现了公平锁,NonFairSync实现了非公平锁
ReentrantLock公平锁和非公平锁
//默认使用非公平锁
ReentrantLock reentrantLock = new ReentrantLock();
//如下构造方法:
public ReentrantLock() {
sync = new NonfairSync();
}
//可以指定参数为公平还是非公平锁 true代表公平,false非公平
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
//当调用lock方法时,ReentrantLock类会根据具体的参数来指定调用公平锁
//还是非公平锁的lock方法
public void lock() {
sync.lock();
}
AbstractQueuedSynchronizer类:
1、Node类是一个双向链表,是AQS中的阻塞队列,当线程获取不到锁时,
会将自己封装成一个Node节点加入到阻塞队列中。
2、Node中包括了链表的前后节点pre,next,Node代表的当前线程thread,
以及当前线程的状态waitStaus
3、在AQS类中声明了一些变量:
state = 0 时表示没有线程获取锁
state = 1 时表示有线程已经获取了锁
4、AQS中还有一些抽象的方法,需要子类去重写的。
AQS类信息
//阻塞队列的头节点,也是当前拥有锁的线程
private transient volatile Node head;
//阻塞队列的尾节点
private transient volatile Node tail;
//锁同步状态 0 代表没有线程拥有锁,1代表有线程已经拥有锁
//锁重入导致state可以 > 1
private volatile int state;
//节点信息,具体内容看下面
static final class Node{}
Node信息
//共享模式的节点,本篇文章不涉及
static final Node SHARED = new Node();
//独占模式
static final Node EXCLUSIVE = null;
//waitStatus状态之一:线程 取消 ,不再获取锁
static final int CANCELLED = 1;
//waitStatus状态之一 : 表示当前线程可以被前一个节点的线程唤醒,
//记住这唤醒是由阻塞队列中前一个节点来唤醒后一个节点的线程的
static final int SIGNAL = -1;
//waitStatus状态之一 :条件队列的状态,这篇不涉及
static final int CONDITION = -2;
//waitStatus状态之一 :先不涉及
static final int PROPAGATE = -3;
//节点中线程等待的状态
volatile int waitStatus;
//前一个节点
volatile Node prev;
//后一个节点
volatile Node next;
//当前节点锁代表的线程
volatile Thread thread;
//条件队列中的等待线程,这里先不涉及
Node nextWaiter;
这篇文章先主要介绍加锁和解锁过程,关于条件队列的一些内容先不涉及。
加锁过程源码
这里以公平锁举例:
//当我们调用lock方法时
final void lock() {
//这里调用了AQS类中的acquire方法
acquire(1);
}
//接下来调用了acquire方法
public final void acquire(int arg) {
/**
1、tryAcquire方法时需要自己重写的方法,
也就是FairSync实现的,目的是为了先去尝试获取锁
即将state试图修改为1,如果这里就返回true,即获取到锁了,
那么就不会继续往下执行了。
2、如果没有获取到锁,则只需执行
acquireQueued
(addWaiter(Node.EXCLUSIVE), arg) 方法
目的是将当前线程包装成一个Node节点加入到阻塞队列中
并将当前线程挂起
**/
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
//先执行tryAcquire 方法
protected final boolean tryAcquire(int acquires) {
//获取当前线程
final Thread current = Thread.currentThread();
int c = getState();
// c == 0 说明当前没有线程获取锁
if (c == 0) {
/**因为是公平锁,所以要讲究先来后到
1、hasQueuedPredecessors()方法要判断一下阻塞队列中、
是否已经由其他线程再排队了
2、如果没有线程排队则直接执行
compareAndSetState(0, acquires) 来试图获取锁
**/
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
//如果获取锁成功,要将当前线程标记为独占锁
setExclusiveOwnerThread(current);
//返回true
return true;
}
}
//如果c != 0 要判断当前拥有锁的线程是不是自己
//这里为了实现重入锁
else if (current == getExclusiveOwnerThread()) {
//如果是自己的话,让state值 + 1
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
//state 赋值
setState(nextc);
//获取锁成功,返回true
return true;
}
/**否则,获取锁失败,返回false,返回false后需要继续返回到
acquire方法继续执行
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
**/
return false;
}
当返回执行acquire方法时,先要执行addWaiter(Node.EXCLUSIVE)方法,将节点加入到阻塞队列中。如下:
//将当前线程封装成Node加入到阻塞队列中
private Node addWaiter(Node mode) {
//封装成node节点,waitStats默认值为0
Node node = new Node(Thread.currentThread(), mode);
//将pred节点执行尾节点
//这里千万不要迷惑,这里pred只是定义了一个临时变量
Node pred = tail;
//如果尾节点不为null
if (pred != null) {
//将当前节点的prev节点设置为pred节点
//即当前节点的前一个节点设置为原来的尾节点
//此时当前节点将会作为尾节点
node.prev = pred;
//通过CAS操作将tail节点替换为当前节点
if (compareAndSetTail(pred, node)) {
//替换成功后,将原来尾节点的next节点指向当前节点
//这样就完成了入队操作
pred.next = node;
//返回当前节点
return node;
}
}
/**
如果pred节点为null,说明链表是空的,阻塞队列为空、
或者CAS设置尾节点失败,会执行到这里
enq方法就是采用自旋的方法将node节点入队
**/
enq(node);
return node;
}
//采用自旋的方式将Node节点加入到阻塞队列中
private Node enq(final Node node) {
//自旋不断的循环尝试
for (;;) {
Node t = tail;
//如果队列为空,tail为null时
if (t == null) { // Must initialize
//要先将head进行初始化,通过CAS设置头结点head
if (compareAndSetHead(new Node()))
//如果设置head成功,将tail指向head
tail = head;
} else {
//如果t不为null,将当前节点node的prev节点设为t
//(试图将node设置为阻塞队列的对尾)
node.prev = t;
//通过CAS设置tail节点
if (compareAndSetTail(t, node)) {
//设置tail成功后,将t的next设置为node
t.next = node;
return t;
}
//如果失败继续循环尝试
}
}
}
//将当前节点加入到阻塞队列后,要根据队列中节点的状态进行判断是否要
//进行挂起当前线程,true表示要挂起,false不挂起,正常应该返回false
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
//是否需要挂起,否
boolean interrupted = false;
//自旋判断是否要挂起当前线程
for (;;) {
//当前节点的前一个节点
final Node p = node.predecessor();
//如果当前节点是head之后的第一个节点,那么尝试去获取锁
if (p == head && tryAcquire(arg)) {
//如果获取锁成功,则将当前节点设置为head
setHead(node);
p.next = null; // help GC
failed = false;
//返回false,不挂起
return interrupted;
}
/**如果不符合上面的条件
1.node不是队列中第一个节点,2.尝试获取锁失败
则判断是否要挂起当前线程
当挂起线程时,要等待前一个节点唤醒后一个节点,唤醒时,
要接着当前位置的代码继续循环获取锁(这里是自旋不断的循环)
**/
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
//当发生异常时
if (failed)
//将当前节点标记为cancle状态
cancelAcquire(node);
}
}
//当跟head节点竞争获取锁失败时,要根据前一个节点的状态判断是否要挂起当前线程
//true 挂起,false不挂起
private static boolean shouldParkAfterFailedAcquire(Node pred,
Node node) {
//前一个节点的状态
int ws = pred.waitStatus;
//如果前一个节点状态为 SIGNAL = -1 时
if (ws == Node.SIGNAL)
/*
* 要挂起当前线程
*/
return true;
//如果前一个节点的状态>0 只有取消状态为1
if (ws > 0) {
/*
*从当前节点开始向前寻找,直到前一个节点的状态<= 0 为止
将 < = 0 的节点作为当前节点的前一个节点
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
*状态为 0 或 -2, -3
这个时候将前一个节点状态设置为SIGNAL,
表示当前节点可以被唤醒状态
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
//如果不是SIGNAL,则返回不挂起
return false;
}
/**
* 如果shouldParkAfterFailedAcquire 返回true表示线程在挂起过程中被中断了
* 则执行此方法挂起当前线程
**/
private final boolean parkAndCheckInterrupt() {
//挂起线程
LockSupport.park(this);
return Thread.interrupted();
}
//标记节点取消的方法
private void cancelAcquire(Node node) {
// Ignore if node doesn't exist
if (node == null)
return;
node.thread = null;
// 将当前节点的前一个节点指向最近一个节点状态 < =0 的节点
//跳过前面所有取消的节点
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// 标记当前节点前一个节点的下一个节点
Node predNext = pred.next;
// 将当前节点的状态设置为canceled
node.waitStatus = Node.CANCELLED;
//这里是要做出队操作
// 如果当前节点是尾节点,那么将当前节点的前一个节点设置为尾节点
if (node == tail && compareAndSetTail(node, pred)) {
//将前一个节点的next节点设置为null
compareAndSetNext(pred, predNext, null);
} else {
int ws;
//如果node不是tail也不是head后的第一个节点,而是一个中间的节点
if (pred != head &&
//并且前一个节点是可唤醒状态(如果不是 -1,只要<0 就设置为-1)
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred,
ws, Node.SIGNAL))) &&
pred.thread != null) {
//将node节点出队,将前一个节点的next指向当前node节点的next
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
//当node为head的下一个节点时,进行出队并唤醒
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
//走到此方法,说明当前线程要取消了
//当前节点的线程为head节点之后的第一个节点时,
//对node节点进行出队,并唤醒后继节点
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
*对node节点进行出队,从后往前遍历找到最近next节点 < = 0
的节点作为next
*/
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)
s = t;
}
if (s != null)
//唤醒后继节点
LockSupport.unpark(s.thread);
}
至此,加锁过程的代码基本上就结束了。
画张图总结一下整个过程吧。更清晰一点。
解锁过程
接下来是解锁过程,这个比较简单,每次解锁都要让state -1,因为有重入,所以要判断最终state是否为0
public void unlock() {
//调用AQS中的release方法
sync.release(1);
}
//AQS类中的释放锁方法
public final boolean release(int arg) {
//tryRelease为Sync中重写的方法
if (tryRelease(arg)) {
//如果释放成功了
Node h = head;
//头节点不为null,并且状态不为0
//这里为啥是不为0呢?我自己的理解是当唤醒时,可以
//去查看unparkSuccessor方法,会将node状态设置为0
//所以在唤醒前要不为0
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
//回到Sync类中看tryRelease方法
protected final boolean tryRelease(int releases) {
//释放锁时,每次 state -1
int c = getState() - releases;
//释放的锁必须是当前线程拥有的锁才可以释放
if (Thread.currentThread() !=
getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//如果c已经为0了,说明已经不持有锁了
if (c == 0) {
free = true;
//将独占锁当前线程设为null
setExclusiveOwnerThread(null);
}
//如果c!=0
//给c赋值
setState(c);
return free; //返回释放释放
}
好了AQS中加锁和解锁过程基本上就已经介绍完了。
总结
回头看看总觉得还是有点乱了。来个小结吧
1、在加锁和解锁过程中用到CAS的四个地方
- 尝试获取锁更新state状态时 tryAcquire :compareAndSetState
- 向阻塞队列添加节点时 addWaiter : compareAndSetTail
- 根据前驱节点判断是否要挂起当前线程时设置前驱节点的状态:compareAndSetWaitStatus
- 当发生异常取消当前节点时,当前节点出队时 compareAndSetNext
2、用到自旋的两个地方:
- 自旋将node节点设置为tail
- 自旋成为head节点之后的第一个节点去竞争获取锁