by shihang.mai

1. 从大局看

AQS与Lock关系.png

一个排他锁ReentrantLock，一个ReenTrantReadWriteLock，3个同步器分别是CountDownLatch、Semaphore、CyclicBarrier(内部直接使用ReentrantLock，其他都有一个内部类Sync extends AQS)

2. AQS数据结构

AQS数据结构.png

• 有一个同步等待队列。是lock()操作引入的等待
• 还有一个条件变量等待队列。维护等待在条件变量上的等待线程的，Condition.await()引起阻塞的线程。

如上图Node节点，下面解析一下属性

• prev: 队列中，当前节点的前面的节点
• next: 队列中，当前节点的后面的节点
• thread: 当前节点的线程
• nextWaiter: 下一个等待在条件变量队列中的节点
• waitStatus: 当前节点等待在队列中的状态

其中waitStatus是个枚举

1. CANCELLED(int CANCELLED = 1): 表示线程取消了等待
2. SIGNAL(int SIGNAL = -1): 表示后续节点需要被唤醒
3. CONDITION(int CONDITION = -2): 线程等待在条件变量等待队列中
4. PROPAGATE(int PROPAGATE = -3) : 在共享模式下，无条件传播releaseShared状态
5. 0: 初始化状态

3. ReentranLock

源码阅读见另外一篇博客

3.1 重点

• ReentranLock是独占锁

• 用AQS的state=0表示锁空闲,state>0表示锁被占用，重入锁时state值+1。用CAS保证线程间安全，用AQS双向队列实现线程的等待

• 双向队列中节点是Node，Node节点包括属性pre、next、当前线程、waitState、share/exclusive(节点类型)

• 它有公平锁和非公平锁实现

3.2 原理举例

ReenTrantLock举例.png

例如现在有3个线程A、B、C按顺序获取锁，并且A线程一直占用锁

1. 当线程A去获取锁时，先CAS获取锁，当然它必定获取到锁，将state+1,并标记A线程获取到锁
2. 当线程A再次进入一个锁方法，发现和占用锁的线程是同一条线程，将state再+1
3. 当线程B去获取锁，先CAS获取锁，获取失败，那么去初始化AQS双向队列
4. 初始化AQS双向队列，首先去初始化一个哨兵节点，head和tail都指向它，然后将线程B封装为exclusive Node节点，CAS加入到AQS双向队列尾部,并将tail指向B的Node节点，并且维护pre、next，挂起B线程
5. 当线程C去获取锁，先CAS获取锁，获取失败，也将线程C封装为exclusive Node节点，CAS加入到AQS双向队列尾部,并将tail指向C的Node节点，并且维护pre、next，并把前面的B的Node节点的waitState=-1，挂起C线程
6. 当线程A释放锁，那么就会唤醒线程B去CAS获取锁,因为ReentranLock默认是非公平锁，这时是有可能有线程D过来的
7. 如此往复

4. ReentranReadWriteLock

源码阅读见另外一篇博客

4.1 重点

• ReentranReadWriteLock是读写锁
• 用AQS的sate的高16位表示读锁，用低16位表示写锁,用HoldCounter保存每个线程的重入次数。用CAS保证线程间安全，用AQS双向队列实现线程的等待
• 双向队列中Node节点同上

4.2 原理举例

ReenTrantReadWriteLock举例.png

例如现在有6个线程A(读)、B(读)、C(写)、D(读)、E(读)、F(写)按顺序获取锁

1. 当A线程去获取锁时,先CAS获取锁，当然它必定获取到锁，将state高16位+1。并且记录第一个获取读锁的线程为A，第一个线程读锁的重入数+1.

2. 当B线程去获取锁时,先CAS获取锁，发现线程A获得读锁，而B线程也是读操作，B线程也获得锁，将state高16位再+1。使用ThreadLocal记录线程B的读锁重入数，key为ThreadLocalHoldCounter，val为HoldCounter

3. 当C线程去获取锁时,发现有线程占用锁，那么线程C初始化AQS双向队列并封装为exclusive Node节点加入到队尾,并挂起C线程。具体同ReentrentLock

4. 当D线程去获取锁时,发现有线程占用锁，并且AQS队列中C线程等待(写线程),那么封装D线程为share Node节点加入到队尾,将C的Node节点的waitState=-1，并挂起D线程

5. 当E线程去获取锁时,发现有线程占用锁，并且AQS队列中C线程等待(写线程),那么封装E线程为share Node节点加入到队尾,将D的Node节点的waitState=-1，并挂起E线程

6. 当F线程去获取锁时,发现有线程占用锁,那么封装F线程为exclusive Node节点加入到队尾,将E的Node节点的waitState=-1，并挂起F线程

7. 当A、B线程释放锁后，C线程会被唤醒,C线程释放锁后，唤醒D线程，D线程会将waitState改为-3，表示继续唤醒后继节点E线程，如果有多个读，会一直唤醒。F线程为写线程，不会被唤醒，直到前面D、E线程释放锁后再被唤醒

8. 如此往复

5. CountDownLatch

源码阅读见另外一篇博客

5.1 重点

• CountDownLatch是不可复用的
• 相当于倒数器

5.2 原理举例

CountDownLatch举例.png

例如，主线程A创建CountDownLatch(2)，创建2条线程的线程池，线程B、C

1. A线程初始化CountDownLatch时传入值2，即设置AQS的state=2
2. A线程调用await()后，A线程会封装为share Node节点放入AQS双向队列，并挂起A线程
3. 当B线程调用countDown(),那么会将state-1
4. 当C线程调用countDown(),那么会将state再-1,并唤醒A线程继续执行

6. CyclicBarrier

6.1 重点

• 内部使用了ReentranLock和条件队列Condition
• CountDownLatch不可复用，CyclicBarrier可以
• Condition源码阅读

6.2 原理举例

CyclicBarrier举例.png

例如,主线程A创建CyclicBarrier(2,屏障点方法),创建2条线程的线程池，线程B、C

1. A线程初始化CyclicBarrier时传入值2和屏障点方法，这个2会赋值到两个变量上，分别是parties和count，其中parties会永远等于2，而count会递减.这是为了CyclicBarrier可以重复利用。屏障点方法也会保存起来
2. 当B调用await()，count-1，那么B线程会释放AQS中的锁，并将B线程封装为exclusive Node放到Condition队列中，并挂起B线程
3. 当C调用await()，count再-1，已经count==0，那么调用屏障点方法，然后唤醒所有在Condition条件队列中的Node，将它们加入到AQS双向队列中，并且将parties赋值给count重置CyclicBarrier。B、C线程继续执行

7. Semaphore

7.1 重点

• 用于限流

7.2 原理举例

Semaphore举例.png

例如，线程A创建Semaphore(2)，创建3条线程的线程池，线程B、C、D

1. A线程初始化Semaphore时传入值2,即设置AQS的state=2
2. 线程B执行acquire(),那么state-1
3. 线程C执行acquire(),那么state再-1
4. 线程D执行acquire(),许可已经为0，D线程封装为share Node放入AQS双向队列
5. 当B和C其中一个调用release(),会将state+1,会唤醒D线程执行

参考地址:https://blog.csdn.net/wangnanwlw/article/details/109509685?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-1.not_use_machine_learn_pai&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-1.not_use_machine_learn_pai