本文详细介绍了AQS（AbstractQueuedSynchronizer）的特性，包括独占/共享资源、公平/非公平、可重入及等待唤醒机制。重点讨论了ReentrantLock的实现细节，如可中断、超时和公平性，并通过实例展示了其用法。此外，还涵盖了条件变量的使用和等待队列的工作原理。
AQS之ReentrantLock
AQS之ReentrantLock
什么是AQS
java.util.concurrent包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于AbstractQueuedSynchronizer（简称AQS）实现的，AQS是一个抽象同步框架，可以用来实现一个依赖状态的同步器。
JDK中提供的大多数的同步器如Lock, Latch, Barrier等，都是基于AQS框架来实现的
- 一般是通过一个内部类Sync继承AQS
- 将同步器所有调用都映射到Sync对应的方法
AQS的特性：
- 阻塞等待队列
- 共享/独占
- 公平/非公平
- 可重入
- 允许中断
在AQS的内部是通过state来表示资源的可用转态，同时提供了一下三中state的访问方式：
getState()
setState()
compareAndSetState()
AQS的两种资源共享方式
- Exclusive-独占，只有一个线程能执行，如ReentrantLock
- Share-共享，多个线程可以同时执行，如Semaphore/CountDownLatch
AQS的两种队列
- 同步等待队列： 主要用于维护获取锁失败时入队的线程
- 条件等待队列： 调用await()的时候会释放锁，然后线程会加入到条件队列，调用signal()唤醒的时候会把条件队列中的线程节点移动到同步队列中，等待再次获得锁
同时AQS也定义了队列中5个节点状态：
1,值为0，初始化状态，表示当前节点在sync队列中，等待着获取锁。
2,CANCELLED，值为1，表示当前的线程被取消；
3,SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark；
4,CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队列中；
5,PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行；
在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#await方法会释放当前持有的锁，然后阻塞当前线程，同时向Condition队列尾部添加一个节点，所以调用Condition#await方法的时候必须持有锁。
调用Condition#signal方法会将Condition队列的首节点移动到阻塞队列尾部，然后唤醒因调用Condition#await方法而阻塞的线程(唤醒之后这个线程就可以去竞争锁了)，所以调用Condition#signal方法的时候必须持有锁，持有锁的线程唤醒被因调用Condition#await方法而阻塞的线程。
等待唤醒机制之await/signal测试
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 条件等待队列测试
*
* @author Zhao Yun Long
* @version V1.0
* @date 2022/11/11 11:18
*/@Slf4j
public class ConditionTest {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(()->{
lock.lock();
try {
log.info(Thread.currentThread().getName()+"开始处理任务");
log.info("----当前线程thread1调用了await(),释放当前持有的锁，阻塞当前线程---");
condition.await();
log.info(Thread.currentThread().getName()+"重新获取锁结束处理任务");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
},"thread1").start();
new Thread(()->{
lock.lock();
try {
log.info(Thread.currentThread().getName()+"获取锁开始处理任务");
Thread.sleep(2000);
condition.signal();
log.info(Thread.currentThread().getName()+"任务处理结束");
log.info("----当前线程thread2调用了signal(),唤醒因调用Condition#await方法而阻塞的thread1---");
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
},"thread2").start();
}
}
ReentrantLock
什么是ReentrantLock
ReentrantLock是一种基于AQS框架的应用实现，是JDK中的一种线程并发访问的同步手段，它的功能类似于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的使用
- 基础使用
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author Zhao Yun Long
* @Description: ReentrantLock基本使用
* @version V1.0
* @date 2022/11/11 20:27
*/public class ReentrantLockDemo {
private static int num = 0;
private static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(()->{
lock.lock();
try {
for (int j = 0; j < 100000; j++) {
num++;
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
});
thread.start();
thread.join();
}
System.out.println(num);
}
}
- 可重入
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 可重入测试
* @author Zhao Yun Long
* @version V1.0
* @date 2022/11/11 21:01
*/@Slf4j
public class ReentrantLockDemo2 {
private static Lock lock = new ReentrantLock();
public static void reenTrantTest1(){
lock.lock();
try {
log.info("reenTrantTest1 执行");
reenTrantTest2();
}finally {
lock.unlock();
}
}
public static void reenTrantTest2(){
lock.lock();
try {
log.info("reenTrantTest2 执行");
reenTrantTest3();
}finally {
lock.unlock();
}
}
public static void reenTrantTest3(){
lock.lock();
try {
log.info("reenTrantTest3 执行");
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
reenTrantTest1();
}
}
- 可中断
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.ReentrantLock;
/**
* 可中断demo
* * @author Zhao Yun Long
* @version V1.0
* @date 2022/11/11 21:33
*/@Slf4j
public class ReentrantLockDemo3 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread thread1 = new Thread(()->{
log.info("thread1线程启动");
try {
lock.lockInterruptibly();
try {
log.info("thread1线程获取到锁");
}finally {
lock.unlock();
}
}catch (InterruptedException e){
e.printStackTrace();
log.info("thread1等锁的过程中断了");
}
},"thread1");
lock.lock();
try {
log.info("main线程拿到了锁");
thread1.start();
try {
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
thread1.interrupt();
log.info("thread1线程被中断");
}finally {
lock.unlock();
}
}
}
- 锁超时- 立即失败
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.ReentrantLock;
/**
* 锁超时
*
* @author Zhao Yun Long
* @version V1.0
* @date 2022/11/11 22:01
*/@Slf4j
public class ReentrantLockDemo4 {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(()->{
log.info("t1线程启动");
// 注意： 即使是设置的公平锁，此方法也会立即返回获取锁成功或失败，公平策略不生效
if (!lock.tryLock()){
log.info("t1获取锁失败，并立即返回false");
return; }
try {
log.info("t1获取到了锁");
}finally {
lock.unlock();
}
},"t1");
lock.lockInterruptibly();
try {
log.info("main线程获取到了锁");
t1.start();
try {
Thread.sleep(2000);
}catch (InterruptedException e){
e.printStackTrace();
}
} finally {
lock.unlock();
}
}
}
- 锁超时-超时失败
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
* 锁超时
*
* @author Zhao Yun Long
* @version V1.0
* @date 2022/11/11 22:01
*/@Slf4j
public class ReentrantLockDemo4 {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(()->{
log.info("t1线程启动");
// 注意： 即使是设置的公平锁，此方法也会立即返回获取锁成功或失败，公平策略不生效
try {
if (!lock.tryLock(1, TimeUnit.SECONDS)){
log.info("等待 1s 后获取锁失败，返回false");
return; }
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
log.info("t1获取到了锁");
}finally {
lock.unlock();
}
},"t1");
lock.lockInterruptibly();
try {
log.info("main线程获取到了锁");
t1.start();
try {
Thread.sleep(2000);
}catch (InterruptedException e){
e.printStackTrace();
}
} finally {
lock.unlock();
}
}
}
- 公平锁(ReentrantLock 默认是不公平的)
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.ReentrantLock;
/**
* 公平锁
*
* @author Zhao Yun Long
* @version V1.0
* @date 2022/11/11 22:19
*/@Slf4j
public class ReentrantLockDemo5 {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock(true);
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();
}
}
}
- 条件变量
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* 条件变量
*
* @author Zhao Yun Long
* @version V1.0
* @date 2022/11/11 22:26
*/@Slf4j
public class ReentrantLockDemo6 {
private static ReentrantLock lock = new ReentrantLock();
private static Condition singleRowCon = lock.newCondition();
// 玩家数量
private static int players = 1;
// 单排
public void doubleRow(){
lock.lock();
try {
while (players == 1){
try {
log.info("只有一个人，那单排吧");
singleRowCon.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.info("咦，来人了，一起玩吧");
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
ReentrantLockDemo6 reentrantLockDemo6 = new ReentrantLockDemo6();
new Thread(()->{
reentrantLockDemo6.doubleRow();
}).start();
new Thread(()->{
lock.lock();
try {
players = 1;
//叫人来了，告诉他不要单排了，一起玩
singleRowCon.signal();
}finally {
lock.unlock();
}
}).start();
}
}
java.util.concurrent类库中提供Condition类来实现线程之间的协调。调用Condition.await() 方法使线程等待，其他线程调用Condition.signal() 或 Condition.signalAll() 方法唤醒等待的线程。
注意：调用Condition的await()和signal()方法，都必须在lock保护之内
扫一扫
1693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
