AQS独占锁、Reentrantlock源码底层实现
文章目录
- AQS独占锁、Reentrantlock源码
-
- 管程
- AQS原理分析
-
- 简介
- 核心结构
- AQS定义两种队列
- ReentrantLock底层源码
-
- 公平锁与非公平锁
- 可重入锁
- 入口等待队列的入队操作
- 入队后阻塞线程
- 释放锁、唤醒后继节点
- 出队操作
AQS独占锁、Reentrantlock源码
管程
java同步的设计思想
- 管程：管理共享变量以及对共享变量的操作过程，让他们支持并发
- 互斥：同一时刻只允许一个线程访问共享资源
- 同步：线程之间如何通信、协作
管程发展至今，出现过三种不同的管程模型：Hasen模型、Hoare模型和HESA模型。现在广泛应用的是HESA模型
首先入口处有一个共享变量，就是一个标记，当前是否加锁了，如果加锁成功就进行下面的过程，如果加锁失败就进入入口等待队列中等待下一次加锁、这里就实现了互斥性
上图中间部分有两个条件变量，这其实就是生产者与消费者的两个条件变量，生产者生成完和消费者消费完，调用等待方法后是进入到条件变量等待队列中。当被唤醒后需要进入入口等待队列中去重新进行竞争锁
条件变量等待队列要实现的核心方法就是wait() notify() notifyALl()
了解了上面的知识之后，那我们如何实现一把独占锁？
-
定义一个标识变量，用来判断是否加锁，如果没有加锁才可以往下走，如果没有加锁成功那么就进入到一个等待队列中
-
这其中有多个线程修改标识变量的过程，那么我们就可以使用CAS来保证一个时刻只有一个线程修改成功
-
当获取到锁的线程执行完之后，我们就需要唤醒等待队列中的线程，这里就用到了等待唤醒机制
唤醒某一个线程可以使用
LockSupport.park()/unpark(thread)，使用案例如下所示：// 线程A先调用park()方法，等待 LockSupport.park(); // 线程B调用unpark()方法唤醒，下面thread是线程A的对象 Thread thread; LockSupport.unpark(thread);
-
-
条件变量的等待队列无非也就是构建队列、入队、出队。这些都是公共逻辑
对于队列的入队出队、修改CAS的这些公共逻辑，我们可以使用模板模式，完全可以去定义一个抽象类，抽取公共方法。再具体的方法就交给子类自己去实现
AQS原理分析
简介
AQS的全程：AbstractQueuedSynchronizer
java.util.concurrent包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于AbstractQueuedSynchronizer（简称AQS）实现的，AQS是一个抽象同步框架，可以用来实现一个依赖状态的同步器。
JDK中提供的大多数的同步器如Lock, Latch, Barrier等，都是基于AQS框架来实现的
AQS的特性：
- 阻塞等待队列
- 共享/独占
- 公平/非公平
- 可重入
- 允许中断
核心结构
内部维护了一个标识位的变量
// 表示资源的可用状态
private volatile int state;
State三种访问方式：
protected final int getState() {
return state;
}
protected final void setState(int newState) {
state = newState;
}
/**
* CAS方式
*/
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
定义了两种资源访问方式：
- Exclusive-独占，只有一个线程能执行，如ReentrantLock
- Share-共享，多个线程可以同时执行，如Semaphore/CountDownLatch
AQS的获取锁对象的acquire()方法、释放锁的release()方法
// 首先调用我们子类重写的tryAcquire（）方法，如果没有获取到则调用acquireQueued()方法进行等待队列的入队操作
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
// 在unparkSuccessor()方法中就会调用LockSupport.unpark()方法唤醒入口等待队列中的线程
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
AQS的等待唤醒机制，是基于AbstractQueuedSynchronizer中的内部类ConditionObject来实现的
AQS实现时主要实现以下几种方法：
- isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。
- tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
- tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
- tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
- tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。
此时如果再问让我们自己实现一个独占锁，那么就直接继承AQS类，这样对于static状态的维护、未竞争到锁进入入口等待队列中就不用我们自己实现了。然后在子类中自己写加锁与解锁的逻辑
AQS定义两种队列
- 同步等待队列： 主要用于维护获取锁失败时入队的线程。
- 条件等待队列： 调用await()的时候会释放锁，然后线程会加入到条件队列，调用signal()唤醒的时候会把条件队列中的线程节点移动到同步队列中，等待再次获得锁。
AQS 定义了5个队列中节点状态：
- 值为0，初始化状态，表示当前节点在sync队列中，等待着获取锁。
- CANCELLED，值为1，表示当前的线程被取消；
- SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark；
- CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队列中；
- PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行；
同步等待队列
AQS当中的同步等待队列也称CLH队列，CLH队列是Craig、Landin、Hagersten三人发明的一种基于双向链表数据结构的队列，是FIFO先进先出线程等待队列，Java中的CLH队列是原CLH队列的一个变种,线程由原自旋机制改为阻塞机制。
AQS 依赖CLH同步队列来完成同步状态的管理：
- 当前线程如果获取同步状态失败时，AQS则会将当前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程
- 当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。
- 通过signal或signalAll将条件队列中的节点转移到同步队列。（由条件队列转化为同步队列）
条件等待队列
AQS中条件队列是使用单向列表保存的，用nextWaiter来连接:
- 调用
await()方法阻塞线程； - 当前线程存在于同步队列的头结点，调用
await()方法进行阻塞（从同步队列转化到条件队列）
ReentrantLock底层源码
关注的问题：
- 公平锁与非公平锁
- 可重入锁
- 并发场景下入队和出队操作是如何设计的
- 线程竞争锁失败入队阻塞逻辑实现
- 释放锁的线程唤醒阻塞线程出队竞争锁的逻辑实现
公平锁与非公平锁
首先从构造方法中看出，Reentrantlock默认是非公平锁，可以通过传一个boolean值来决定公平与非公平
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
我们现在再来看看lock()方法，这是非公平锁NonfairSync对象中的lock()方法
static final class NonfairSync extends Sync {
final void lock() {
// 这里首先就会调用cas 将static从0变为1
// 如果此时又来了一个新的线程，可能刚好前一个线程释放锁，这里一个新的线程就加锁成功。就相当于插队
if (compareAndSetState(0, 1))
// 这里还会设置一个属性exclusiveOwnerThread= thread，独占的线程为当前线程，这也是后续可重入锁的判断依据
setExclusiveOwnerThread(Thread.currentThread());
else
// 如果没有插队成功就老老实实去走正常获取锁的逻辑
acquire(1);
}
...
}
假如现在这是线程1，此时它最先竞争能够修改成功，然后将独占线程的属性设置为线程1。
然后线程2再来cas修改，修改不成功，就会走到else逻辑中调用acquire(1)方法
public final void acquire(int arg) {
// 插队，去尝试获取锁，如果获取不到就调用acquireQueued()方法进入阻塞队列中
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
尝试获取锁逻辑如下，这里会进入到非公平锁的尝试获取锁逻辑中
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 这个时候线程1已经事先将state改为了1，所以这里目前获取不到锁。
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 这里会判断独占线程exclusiveOwnerThread属性是不是为当前线程thread对象，这是可重入锁的逻辑，后续详细介绍这里
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;
}
此时线程2尝试获取锁会获取不到，返回false，然后就会进入阻塞队列的逻辑中，那么就会有创建队列，入队的操作，后续详细介绍。
我们接下来再看如果是公平锁是什么样子的
static final class FairSync extends Sync {
final void lock() {
// 这里就直接调用加锁的方法，只会加锁一次，而非公平锁刚进lock()方法就会去插队获取一次锁
acquire(1);
}
....
}
可重入锁
我们接下来再来看看尝试获取锁方法的下半部分逻辑
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 这里会判断独占线程exclusiveOwnerThread属性是不是为当前线程thread对象
else if (current == getExclusiveOwnerThread()) {
// c是当前state的值，acquires的值是1 这里每次都会+1
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 然后把相加后的结果重新赋值给state变量
setState(nextc);
return true;
}
return false;
}
入口等待队列的入队操作
线程1已经获取到了锁，将status改为了1，现在又来了一个线程2来获取锁
public final void acquire(int arg) {
// 尝试获取锁如果失败，那么就会调用acquireQueued()方法了
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
Node.EXCLUSIVE表示独占；Node.SHARED表示共享锁
先调用addWaiter()，将当前线程封装为一个Node对象，插入到双向链表的尾部
private Node addWaiter(Node mode) {
// 首先会创建一个新节点
Node node = new Node(Thread.currentThread(), mode);
// 尾结点，刚开始队列都没有，tail节点也是null，所以下面这个if目前还不会执行
// 如果tail节点不为null，就直接把刚刚新建的节点插入到链表的尾部，并维护好prev和next两个指针
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) { // 如果这一次CAS失败了，那么就会进入到enq()方法中循环CAS入队
pred.next = node;
return node;
}
}
// 然后就直接进入到此方法中进行入队
enq(node);
return node;
}
当前创建的节点对象如下，独占方式下主要的属性就是waitStatus和thread这两个
enq(Node node)方法实现如下，如果尾结点为null则进行链表的初始化，如果不为null则循环CAS入队操作。
private Node enq(final Node node) {
// 这里就写了一个循环，一定要入队之后才会跳出循环
for (;;) {
Node t = tail;
if (t == null) { // 如果尾节点为null就必须要进行初始化，就创建一个新节点为头节点。然后把头节点指针和尾结点指针都指向这个新节点
if (compareAndSetHead(new Node())) // head头节点代表当前已经获取到锁的线程
tail = head;
} else {
// 如果尾结点不为null，那么就把最新的Node节点对象插入到链表的尾部，并维护好这个节点和尾结点的双向指令
node.prev = t;
// 把tail指针移动到新插入的node节点上
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
入队后阻塞线程
线程入队之后，我们还需要调用这个线程的LockSupport.park()方法让它进入等待状态，接下来再回到刚开始的入口方法
public final void acquire(int arg) {
// 尝试获取锁如果失败，那么就会调用acquireQueued()方法了
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
现在addWaiter()方法已经执行完入队操作了，接下来就会调用acquireQueued()方法
// 这个方法的实现逻辑就是一个死循环中，判断是否为头节点的下一个节点 并且尝试获取锁。否则就进入等待状态
// 在进入等待状态之前会先将前一个节点的awaitStatus改为-1，当被唤醒后又进行循环尝试获取锁
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
// 返回当前节点的前一个节点p
final Node p = node.predecessor();
// 如果当前节点是头节点的下一个节点，那么就去尝试获取锁，如果成功获取到就把自己变为头节点
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 如果上面的条件不满足，那么线程就开始等待
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
// try语句段中会响应其他线程的中断标识，然后抛异常这里捕获，再执行cancelAcquire()方法。当然响应中断这里不是重点
if (failed)
cancelAcquire(node);
}
}
shouldParkAfterFailedAcquire(Node pred, Node node)方法逻辑如下，
// 将前一个节点的awaitStatus改为-1
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
// 前一个节点的waitStatus为-1就表示当前节点可以被唤醒
return true;
if (ws > 0) {
// 前一个节点被取消了，直接跳过前一个节点
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 初始状态，前一个节点waitStatus为0，所以上面两个条件都不满足，直接调用下面的方法采用CAS的方式将0改为-1
// 目的就是在阻塞当前线程之前，我要做一些准备工作，以便之后可以被唤醒
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
这里就返回false了，再回到上一个acquireQueued()方法中，又会进行一次循环，又会进入到shouldParkAfterFailedAcquire(Node pred, Node node)方法中，这次前一个节点的waitStatus为-1了，所以这次返回了true。
那么就会调用parkAndCheckInterrupt()方法，最终调用了LockSupport.park(this);进入了等待
private final boolean parkAndCheckInterrupt() {
// 调用park()方法 使当前线程进入等待状态
LockSupport.park(this);
return Thread.interrupted();
}
如果此时又来了一个线程3来加锁，那么就会变成下图所示的情况：
释放锁、唤醒后继节点
目前线程2进入了等待状态，线程1继续执行业务逻辑，然后调用lock.unlock();方法释放锁
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
// 释放锁
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
// 唤醒
unparkSuccessor(h);
return true;
}
return false;
}
先执行tryRelease()释放锁
protected final boolean tryRelease(int releases) {
// 首先把state-1，如果没有重入的话，结果就变为0了
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 如果为0就把exclusiveOwnerThread属性变为null
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
// 然后直接更新0，这里就不需要进行CAS操作了，因为只有一个线程会执行
setState(c);
return free;
}
当state变为0后，就调用unparkSuccessor()方法唤醒后继节点
private void unparkSuccessor(Node node) {
/*
* 头节点的waitStatus如果小于0，那么就CAS修改状态再变为0
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* 如果下一个节点为取消状态，那么就继续往后找
*/
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);
}
出队操作
目前线程1已经释放了锁，并且唤醒了线程2，那么就回到线程2进入等待状态的位置
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
// 当被唤醒后，线程2又执行一遍循环
final Node p = node.predecessor();
// 唤醒后，下面这个if就满足条件了，然后当前节点就充当head节点，之前的头节点就出队
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 这里进入等待状态
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}