java并发之AQS详解 ReentrantLock
AQS原理分析
什么是AQS
java.util.concurrent包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队
列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于
AbstractQueuedSynchronizer（简称AQS） 实现的，AQS是一个抽象同步框架，可以用来实
现一个依赖状态的同步器。
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定义两种队列
同步等待队列： 主要用于维护获取锁失败时入队的线程
条件等待队列： 调用await()的时候会释放锁，然后线程会加入到条件队列，调用
signal()唤醒的时候会把条件队列中的线程节点移动到同步队列中，等待再次获得锁
AQS 定义了5个队列中节点状态：
1. 值为0，初始化状态，表示当前节点在sync队列中，等待着获取锁。
2. CANCELLED，值为1，表示当前的线程被取消；
3. SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark；
4. CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队列
中；
5. PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行；
不同的自定义同步器竞争共享资源的方式也不同。自定义同步器在实现时只需要实现共享
资源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接口详解
1. 调用Condition#await方法 会释放当前持有的锁，然后阻塞当前线程，同时向
Condition队列尾部添加一个节点 ，所以调用Condition#await方法的时候必须持有锁。
2. 调用Condition#signal方法会 将Condition队列的首节点移动到阻塞队列尾部，然后唤
醒因调用Condition#await方法而阻塞的线程 (唤醒之后这个线程就可以去竞争锁了)，所
以调用Condition#signal方法的时候必须持有锁，持有锁的线程唤醒被因调用
Condition#await方法而阻塞的线程。
等待唤醒机制之await/signal测试
1 @Slf4j
2 public class ConditionTest {
3
4 public static void main ( String [] args ) {
5
6 Lock lock = new ReentrantLock ();
7 Condition condition = lock . newCondition ();
8
9 new Thread (() ‐> {
10 lock . lock ();
11 try {
12 log . debug ( Thread . currentThread (). getName () + " 开始处理任务 " );
13 condition . await ();
14 log . debug ( Thread . currentThread (). getName () + " 结束处理任务 " );
15 } catch ( InterruptedException e ) {
16 e . printStackTrace ();
17 } finally {
18 lock . unlock ();
19 }
20 }). start ();
21
22 new Thread (() ‐> {
23 lock . lock ();
24 try {
25 log . debug ( Thread . currentThread (). getName () + " 开始处理任务 " );
26
27 Thread . sleep ( 2000 );
28 condition . signal ();
29 log . debug ( Thread . currentThread (). getName () + " 结束处理任务 " );
30 } catch ( Exception e ) {
31 e . printStackTrace ();
32 } finally {
33 lock . unlock ();
34 }
35 }). start ();
36 }
37 }
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
1 ReentrantLock lock = new ReentrantLock (); // 参数默认 false ，不公平锁
2 ReentrantLock lock = new ReentrantLock ( true ); // 公平锁
3
4 // 加锁
5 lock . lock ();
6 try {
7 // 临界区
8 } finally {
9 // 解锁
10 lock . unlock ();
11 }
测试
1 public class ReentrantLockDemo {
2
3 private static int sum = 0 ;
4 private static Lock lock = new ReentrantLock ();
5
6 public static void main ( String [] args ) throws InterruptedException {
7
8 for ( int i = 0 ; i < 3 ; i ++ ) {
9 Thread thread = new Thread (() ‐> {
10 // 加锁
11 lock . lock ();
12 try {
13 for ( int j = 0 ; j < 10000 ; j ++ ) {
14 sum ++ ;
15 }
16 } finally {
17 // 解锁
18 lock . unlock ();
19 }
20 });
21 thread . start ();
22 }
23 Thread . sleep ( 2000 );
24 System . out . println ( sum );
25 }
26 }
可重入
1 @Slf4j
2 public class ReentrantLockDemo2 {
3
4 public static ReentrantLock lock = new ReentrantLock ();
5
6 public static void main ( String [] args ) {
7 method1 ();
8 }
9
10
11 public static void method1 () {
12 lock . lock ();
13 try {
14 log . debug ( "execute method1" );
15 method2 ();
16 } finally {
17 lock . unlock ();
18 }
19 }
20 public static void method2 () {
21 lock . lock ();
22 try {
23 log . debug ( "execute method2" );
24 method3 ();
25 } finally {
26 lock . unlock ();
27 }
28 }
29 public static void method3 () {
30 lock . lock ();
31 try {
32 log . debug ( "execute method3" );
33 } finally {
34 lock . unlock ();
35 }
36 }
37 }
可中断
1 @Slf4j
2 public class ReentrantLockDemo3 { 3
4 public static void main ( String [] args ) {
5 ReentrantLock lock = new ReentrantLock ();
6
7 Thread t1 = new Thread (() ‐> {
8
9 log . debug ( "t1 启动 ..." );
10
11 try {
12 lock . lockInterruptibly ();
13 try {
14 log . debug ( "t1 获得了锁 " );
15 } finally {
16 lock . unlock ();
17 }
18 } catch ( InterruptedException e ) {
19 e . printStackTrace ();
20 log . debug ( "t1 等锁的过程中被中断 " );
21 }
22
23 }, "t1" );
24
25 lock . lock ();
26 try {
27 log . debug ( "main 线程获得了锁 " );
28 t1 . start ();
29 // 先让线程 t1 执行
30 try {
31 Thread . sleep ( 1000 );
32 } catch ( InterruptedException e ) {
33 e . printStackTrace ();
34 }
35 t1 . interrupt ();
36 log . debug ( " 线程 t1 执行中断 " );
37 } finally {
38 lock . unlock ();
39 }
40 }
41 }
锁超时
立即失败 1 @Slf4j
2 public class ReentrantLockDemo4 {
3
4 public static void main ( String [] args ) {
5 ReentrantLock lock = new ReentrantLock ();
6
7 Thread t1 = new Thread (() ‐> {
8
9 log . debug ( "t1 启动 ..." );
10 // 注意： 即使是设置的公平锁，此方法也会立即返回获取锁成功或失败，公平策略不生效
11 if ( ! lock . tryLock ()) {
12 log . debug ( "t1 获取锁失败，立即返回 false" );
13 return ;
14 }
15 try {
16 log . debug ( "t1 获得了锁 " );
17 } finally {
18 lock . unlock ();
19 }
20
21 }, "t1" );
22
23
24 lock . lock ();
25 try {
26 log . debug ( "main 线程获得了锁 " );
27 t1 . start ();
28 // 先让线程 t1 执行
29 try {
30 Thread . sleep ( 1000 );
31 } catch ( InterruptedException e ) {
32 e . printStackTrace ();
33 }
34 } finally {
35 lock . unlock ();
36 }
37
38 }
39
40 }
超时失败
1 @Slf4j 2 public class ReentrantLockDemo4 {
3
4 public static void main ( String [] args ) {
5 ReentrantLock lock = new ReentrantLock ();
6 Thread t1 = new Thread (() ‐> {
7 log . debug ( "t1 启动 ..." );
8 // 超时
9 try {
10 if ( ! lock . tryLock ( 1 , TimeUnit . SECONDS )) {
11 log . debug ( " 等待 1s 后获取锁失败，返回 " );
12 return ;
13 }
14 } catch ( InterruptedException e ) {
15 e . printStackTrace ();
16 return ;
17 }
18 try {
19 log . debug ( "t1 获得了锁 " );
20 } finally {
21 lock . unlock ();
22 }
23
24 }, "t1" );
25
26
27 lock . lock ();
28 try {
29 log . debug ( "main 线程获得了锁 " );
30 t1 . start ();
31 // 先让线程 t1 执行
32 try {
33 Thread . sleep ( 2000 );
34 } catch ( InterruptedException e ) {
35 e . printStackTrace ();
36 }
37 } finally {
38 lock . unlock ();
39 }
40
41 }
42
43 }
公平锁
ReentrantLock 默认是不公平的
1 @Slf4j
2 public class ReentrantLockDemo5 {
3
4 public static void main ( String [] args ) throws InterruptedException {
5 ReentrantLock lock = new ReentrantLock ( true ); // 公平锁
6
7 for ( int i = 0 ; i < 500 ; i ++ ) {
8 new Thread (() ‐> {
9 lock . lock ();
10 try {
11 try {
12 Thread . sleep ( 10 );
13 } catch ( InterruptedException e ) {
14 e . printStackTrace ();
15 }
16 log . debug ( Thread . currentThread (). getName () + " running..." );
17 } finally {
18 lock . unlock ();
19 }
20 }, "t" + i ). start ();
21 }
22 // 1s 之后去争抢锁
23 Thread . sleep ( 1000 );
24
25 for ( int i = 0 ; i < 500 ; i ++ ) {
26 new Thread (() ‐> {
27 lock . lock ();
28 try {
29 log . debug ( Thread . currentThread (). getName () + " running..." );
30 } finally {
31 lock . unlock ();
32 }
33 }, " 强行插入 " + i ). start ();
34 }
35 }
36 }
思考： ReentrantLock公平锁和非公平锁的性能谁更高？ 条件变量
java.util.concurrent类库中提供Condition类来实现线程之间的协调。调用
Condition.await() 方法使线程等待，其他线程调用Condition.signal() 或
Condition.signalAll() 方法唤醒等待的线程。
注意： 调用Condition的await()和signal()方法，都必须在lock保护之内。
1 @Slf4j
2 public class ReentrantLockDemo6 {
3 private static ReentrantLock lock = new ReentrantLock ();
4 private static Condition cigCon = lock . newCondition ();
5 private static Condition takeCon = lock . newCondition ();
6
7 private static boolean hashcig = false ;
8 private static boolean hastakeout = false ;
9
10 // 送烟
11 public void cigratee (){
12 lock . lock ();
13 try {
14 while ( ! hashcig ){
15 try {
16 log . debug ( " 没有烟，歇一会 " );
17 cigCon . await ();
18
19 } catch ( Exception e ){
20 e . printStackTrace ();
21 }
22 }
23 log . debug ( " 有烟了，干活 " );
24 } finally {
25 lock . unlock ();
26 }
27 }
28
29 // 送外卖
30 public void takeout (){
31 lock . lock ();
32 try {
33 while ( ! hastakeout ){
34 try {
35 log . debug ( " 没有饭，歇一会 " );
36 takeCon . await (); 37
38 } catch ( Exception e ){
39 e . printStackTrace ();
40 }
41 }
42 log . debug ( " 有饭了，干活 " );
43 } finally {
44 lock . unlock ();
45 }
46 }
47
48 public static void main ( String [] args ) {
49 ReentrantLockDemo6 test = new ReentrantLockDemo6 ();
50 new Thread (() ‐> {
51 test . cigratee ();
52 }). start ();
53
54 new Thread (() ‐> {
55 test . takeout ();
56 }). start ();
57
58 new Thread (() ‐> {
59 lock . lock ();
60 try {
61 hashcig = true ;
62 // 唤醒送烟的等待线程
63 cigCon . signal ();
64 } finally {
65 lock . unlock ();
66 }
67
68
69 }, "t1" ). start ();
70
71 new Thread (() ‐> {
72 lock . lock ();
73 try {
74 hastakeout = true ;
75 // 唤醒送饭的等待线程
76 takeCon . signal ();
77 } finally {
78 lock . unlock (); 79 }
80 }, "t2" ). start ();
81 }
82
83 }