关于深入理解AQS之独占锁ReentrantLock
一、AQS原理分析
AQS介绍
java.util.concurrent 包中的大多数同步器实现都是围绕着共同的基础行为，如等待队列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于 **AbstractQueuedSynchronizer（简称AQS）**实现的，AQS 是一个抽象同步框架，可用来实现一个依赖状态的同步器。
管程：一般使用 MESA，其中有两个队列：①同步等待队列（即上图的入口等待队列，获取锁有关，获取锁失败的线程会加入此队列），②条件等待队列（阻塞唤醒机制）
JVM 层面对管程的实现为synchronized：
ObjectMonitor、cxq（cas、owner）、waitSet（wait/notify、notifyAll）
Java 层面对管程的实现为 AQS 抽象层：
同步等待队列（cas、volatile int state）：入队、出队；加锁、解锁（具体的实现）
条件等待队列（Condition、await/signal、signalAll）：入队、出队
JDK 中提供的大多数的同步器如 Lock, Latch, Barrier 等，都是基于 AQS 框架来实现的
- 一般是通过一个内部类 Sync 继承 AQS
- 将同步器所有调用都映射到 Sync 对应的方法
AQS具备的特性
- 阻塞等待队列
- 共享/独占
- 公平/非公平
- 可重入
- 允许中断
AQS内部维护属性volatile int state
- state 表示资源的可用状态
state三种访问方式
- getState()
- setState()
- compareAndSetState()
AQS定义两种资源共享方式
- Exclusive - 独占，只有一个线程能执行，如 ReentrantLock
- Share - 共享，多个线程可以同时执行，如 Semaphore/CountDownLatch
AQS定义两种队列
- 同步等待队列
- 条件等待队列
不同的自定义同步器竞争共享资源的方式也不同。
自定义同步器在实现时只需实现共享资源 state 的获取与释放方式即可，具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已在顶层实现。
自定义同步器实现时主要实现以下几种方法：
- isHeldExclusively()：该线程是否正在独占资源。只有用到 condition 才需去实现。
- tryAcquire(int)：独占方式。尝试获取资源，成功则返回 true，失败则返回 false。
- tryRelease(int)：独占方式。尝试释放资源，成功则返回 true，失败则返回 false。
- tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0 表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
- tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回 true，否则返回 false。
同步等待队列
AQS 当中的同步等待队列也称 CLH 队列，CLH队列是 Craig、Landin、Hagersten 三人发明的一种基于双向链表数据结构的队列，是 FIFO（先入先出）线程等待队列，Java 中的 CLH 队列是原 CLH 队列的一个变种，线程由原自旋机制改为阻塞机制。
AQS 依赖 CLH 同步队列来完成同步状态的管理：
- 当前线程若获取同步状态失败，AQS 则会将当前线程已经等待状态等信息构造成一个节点（Node），并将其加入到 CLH 同步队列，同时会阻塞当前线程。
- 当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。
- 通过 signal 或 signalAll 将条件队列中的节点转移到同步队列（由条件队列转化为同步队列）。
条件等待队列
AQS 中条件队列是使用单向列表保存的，用 nextWaiter 来连接:
- 调用 await 方法阻塞线程
- 当前线程存在于同步队列的头结点，调用 await 方法进行阻塞（从同步队列转化到条件队列）
Condition接口详解
- 调用 Condition#await 方法会释放当前持有的锁，然后阻塞当前线程，同时向 Condition 队列尾部添加一个节点，所以调用 Condition#await 方法时必须持有锁。
- 调用 Condition#signal 方法会将 Condition 队列的首节点移动到阻塞队列尾部，然后唤醒因调用 Condition#await 方法而阻塞的线程（唤醒后此线程即可去竞争锁），所以调用 Condition#signal 方法候必须持有锁，持有锁的线程唤醒被因调用 Condition#await 方法而阻塞的线程。
等待唤醒机制之await/signal测试
public class ConditionTest {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
lock.lock();
try {
System.out.println(">>>>>>>>>> " + Thread.currentThread().getName() + "开始处理任务");
condition.await();
System.out.println(">>>>>>>>>> " + Thread.currentThread().getName() + "结束处理任务");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
new Thread(() -> {
lock.lock();
try {
System.out.println(">>>>>>>>>> " + Thread.currentThread().getName() + "开始处理任务");
condition.signal();
System.out.println(">>>>>>>>>> " + Thread.currentThread().getName() + "结束处理任务");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
}
}
二、ReentrantLock详解
ReentrantLock 是一种基于AQS框架的应用实现，是JDK中的一种线程并发访问的同步手段，它的功能类似于 synchronized，是一种互斥锁，可以保证线程安全。
相对于 synchronized， ReentrantLock 具备如下特点：
- 可中断
- 可以设置超时时间
- 可以设置为公平锁
- 支持多个条件变量
- 与 synchronized 一样，都支持可重入
synchronized和ReentrantLock的区别：
- synchronized是JVM层次的锁实现，ReentrantLock是JDK层次的锁实现；
- synchronized的锁状态是无法在代码中直接判断的，但是ReentrantLock可以通过ReentrantLock#isLocked判断；
- synchronized是非公平锁，ReentrantLock是可以是公平也可以是非公平的；
- synchronized是不可以被中断的，而ReentrantLock#lockInterruptibly方法是可以被中断的；
- 在发生异常时synchronized会自动释放锁，而ReentrantLock需要开发者在finally块中显示释放锁；
- ReentrantLock获取锁的形式有多种：如立即返回是否成功的tryLock(),以及等待指定时长的获取，更加灵活；
- synchronized在特定的情况下对于已经在等待的线程是后来的线程先获得锁（回顾一下sychronized的唤醒策略），而ReentrantLock对于已经在等待的线程是先来的线程先获得锁；
ReentrantLock的使用
同步执行，类似于synchronized：
// 参数默认 false，不公平锁
ReentrantLock lock = new ReentrantLock();
// 公平锁
ReentrantLock lock = new ReentrantLock(true);
// 加锁
lock.lock();
try {
// 临界区
} finally {
// 解锁
lock.unlock();
}
同步执行：
public class ReentrantLockDemo {
private static int sum = 0;
private static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 3; i++) {
Thread thread = new Thread(() -> {
//加锁
lock.lock();
try {
//临界区代码
//TODO 业务逻辑：读写操作不能保证线程安全
for (int j = 0; j < 10000; j++) {
sum++;
}
} finally {
//解锁
lock.unlock();
}
});
thread.start();
}
Thread.sleep(2000);
System.out.println(sum);
}
}
可重入：
@Slf4j
public class ReentrantLockDemo2 {
private static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
method1();
}
public static void method1() {
lock.lock();
try {
log.debug("execute method1");
method2();
} finally {
lock.unlock();
}
}
public static void method2() {
lock.lock();
try {
log.debug("execute method2");
method3();
} finally {
lock.unlock();
}
}
public static void method3() {
lock.lock();
try {
log.debug("execute method3");
} finally {
lock.unlock();
}
}
}
可中断：
@Slf4j
public class ReentrantLockDemo3 {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
log.debug("t1启动……");
try {
lock.lockInterruptibly();
try {
log.debug("t1获得了锁");
} finally {
lock.unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
log.debug("t1等锁的过程被中断");
}
}, "t1");
lock.lock();
try {
log.debug("main线程获得了锁");
t1.start();
//先让线程 t1 执行
Thread.sleep(1000);
t1.interrupt();
log.debug("线程 t1 执行中断");
} finally {
lock.unlock();
}
}
}
锁超时 - 立即失效：
@Slf4j
public class ReentrantLockDemo3 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
log.debug("t1启动……");
// 注意：即使是设置公平锁，此方法也会立即返回获取锁成功或失败，公平策略不生效
if (!lock.tryLock()) {
log.debug("t1获取锁失败，立即返回false");
return;
}
try {
log.debug("t1获得锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
try {
log.debug("main线程获得了锁");
t1.start();
//先让线程 t1 执行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} finally {
lock.unlock();
}
}
}
锁超时 - 超时失效：
@Slf4j
public class ReentrantLockDemo4 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
log.debug("t1启动……");
// 超时
try {
if (!lock.tryLock(1, TimeUnit.SECONDS)) {
log.debug("等待 1s 后获取锁失败，返回");
return;
}
} catch (InterruptedException e) {
e.printStackTrace();
return;
}
try {
log.debug("t1获得锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
try {
log.debug("main线程获得了锁");
t1.start();
//先让线程 t1 执行
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} finally {
lock.unlock();
}
}
}
公平锁：
ReentrantLock 默认是不公平的
@Slf4j
public class ReentrantLockDemo5 {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock(true);// 公平锁
//ReentrantLock lock = new ReentrantLock();// 非公平锁
for (int i = 0; i < 500; i++) {
new Thread(() -> {
lock.lock();
try {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug(Thread.currentThread().getName() + " running……");
} finally {
lock.unlock();
}
}, "t" + i).start();
}
// 1s 后去争抢锁
Thread.sleep(1000);
for (int i = 0; i < 500; i++) {
new Thread(() -> {
lock.lock();
try {
log.debug(Thread.currentThread().getName() + " running……");
} finally {
lock.unlock();
}
}, "强行插入" + i).start();
}
}
}
非公平锁后续去竞争锁的时候不会直接去排队，会先尝试获取锁，因此非公平锁会提高并发量，效率比直接去排队的公平锁高
条件变量
java.util.concurrent 类库中提供 Condition 类来实现线程之间的协调。
调用 Condition.await() 使线程等待，其他线程调用 Condition.signal() 或 Condition.signalAll() 唤醒等待的线程。
注意：调用 Condition 的await() 和 signal()，都必须在 lock 保护之内。
@Slf4j
public class ReentrantLockDemo6 {
private static ReentrantLock lock = new ReentrantLock();
private static Condition cigCon = lock.newCondition();
private static Condition takeCon = lock.newCondition();
private static boolean hasCig = false;
private static boolean hasTakeout = false;
// 送烟
public void cigarette() {
lock.lock();
try {
while (!hasCig) {
try {
log.debug("没有烟，歇一会儿");
cigCon.await();
} catch (Exception e) {
e.printStackTrace();
}
}
log.debug("有烟了，干活");
} finally {
lock.unlock();
}
}
// 送外卖
public void takeout() {
lock.lock();
try {
while (!hasTakeout) {
try {
log.debug("没有饭，歇一会儿");
takeCon.await();
} catch (Exception e) {
e.printStackTrace();
}
}
log.debug("有饭了，干活");
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
ReentrantLockDemo6 test = new ReentrantLockDemo6();
new Thread(() -> test.cigarette()).start();
new Thread(() -> test.takeout()).start();
new Thread(() -> {
lock.lock();
try {
hasTakeout = true;
// 唤醒外卖的等待线程
takeCon.signal();
}finally {
lock.unlock();
}
}).start();
}
}
加锁会放在 try … catch 语句块外面，即加锁后面会紧跟着 try … catch 语句块
锁分类
- 线程需不需锁住同步资源
- 锁住：悲观锁
- 不锁住：乐观锁
- 等锁的过程
- 不停地尝试获取锁：自旋锁
- 阻塞型的：非自旋锁
- 是否可以中断
- 可以：可中断锁
- 不可用：不可中断锁
- 同一个线程是否可以重复获取一把锁
- 可以：可重入锁
- 不可用：不可重入锁
- 多个线程竞争时，是否需要排队
- 需要：公平锁
- 不需要：非公平锁
- 多线程能否共享一把锁
- 可以共享：共享锁
- 不可以共享：独占锁
- synchronized中锁竞争程度
- 偏向锁
- 轻量级锁
- 重量级锁
ReentrantLock源码分析
关注点：
- ReentrantLock加锁解锁的逻辑
- 公平和非公平，可重入锁的实现
- 线程竞争锁失败入队阻塞逻辑和获取锁的线程释放锁唤醒阻塞线程竞争锁的逻辑实现 （ 设计的精髓：并发场景下入队和出队操作）
流程：
第一个线程 t0 启动后，会通过 CAS 尝试加锁，将 state 从 0 改为 1，即加锁成功，将 t0 线程赋值给 exclusiveOwnerThread 变量（用于重入锁的判断：当前线程是否等于此变量的值）；
第二个线程 t1 启动后，通过 CAS 尝试加锁，由于 t0 已获取锁，因此 t1 会加锁失败，进行阻塞（acquire(1)），将 t1 添加到等待队列 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))，即创建节点入队
源码精髓：
链表入队操作：
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
初始进来 tail 为 null，enq(node) 创建队列，即构建链表
并发场景下构建链表：
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
head 节点实际上是指向加锁成功的线程，head 的后继节点才能被唤醒
919
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
