独占锁
早上叫练带着一家三口来到了南京市第一医院做核酸检测，护士小姐姐站在医院门口拦着通知咱们人比拟多，无论小孩儿小孩，须要排队一个个期待医生采集唾液检测，OK，上面咱们用代码 + 图看看咱们一家三口是怎么排队的！
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* _@author_ ：__jiaolian
* _@date_ ：__Created in 2021-01-22 10:33
* _@description__：独占锁测试_
* _@modified_ By__：
* _公众号__:__叫练_
*/
public class ExclusiveLockTest {
**private** **static** `ReentrantReadWriteLock lock =` **new** `ReentrantReadWriteLock();` **private** **static** `ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();` _//__医院_ **private** **static** **class** **Hospital** `{` **private** `String name;` **public** **Hospital**(String name) `{` **this**`.name = name;` } _//__核酸检测排队测试_ **public** **void** **checkUp**() `{` **try** `{` writeLock.lock(); `System.out.println(Thread.currentThread().getName()+`"正在做核酸检测"`);` _//__核酸过程__...__好受__..._ `Thread.sleep(`3000`);` `}` **catch** `(InterruptedException e) {` e.printStackTrace(); `}` **finally** `{` writeLock.unlock(); } } } **public** **static** **void** **main**(String[] args) **throws** InterruptedException `{` `Hospital hospital =` **new** `Hospital(`"南京市第一医院"`);` `Thread JLWife =` **new** `Thread(()->hospital.checkUp(),`"叫练妻"`);` JLWife.start(); _//__睡眠__100__毫秒是让一家三口是有程序的排队去检测_ `Thread.sleep(`100`);` `Thread JLSon =` **new** `Thread(()->hospital.checkUp(),`"叫练子"`);` JLSon.start(); `Thread.sleep(`100`);` `Thread JL =` **new** `Thread(()->hospital.checkUp(),`"叫练"`);` JL.start(); }`}`如上代码：在主线程启动三个线程去医院门口排队，女士优先，叫练妻是排在最后面的，两头站的是叫练的孩子，最初就是叫练本人了。咱们假如模仿了下核酸检测一次须要3秒。代码中咱们用了独占锁，独占锁能够了解成医院只有一个医生，一个医生同时只能为一个人做核酸，所以须要一一排队检测，所以代码执行结束一共须要破费9秒，核酸检测就能够全副做完。代码逻辑还是比较简单，和咱们之前文章形容 synchronized 同理。核酸排队咱们用图形容下吧！
AQS 全称是 AbstractQueueSynchroniz，意为队列同步器，实质上是一个双向链表，在 AQS 外面每个线程都被封装成一个 Node 节点，每个节点都通过尾插法增加。另外节点还有还封装状态信息，比方是独占的还是共享的，如下面的案例就示意独占 Node，医生他自身是一种共享资源，在 AQS 外部外面叫它 state，用 int 类型示意，线程都会通过 CAS 的形式争抢 state。线程抢到锁了，就自增，没有抢到锁的线程会阻塞期待机会被唤醒。如下图：依据咱们了解形象进去 AQS 的内部结构。
依据下面形容，大家看 AQS 不就是用 Node 封装线程，而后把线程依照先来后到（非偏心锁除外）连接起来的双向链表嘛！对于非偏心锁我之前写《排队打饭》案例中也通过简略例子形容过。有趣味童鞋能够翻看下！
共享锁
下面咱们做核酸的过程是同步执行的，叫独占锁。那共享锁是什么意思呢？当初叫练孩子只有 3 岁，不能独立实现核酸检测，护士小姐姐感同身受，察看叫练子是排在叫练妻前面的，就让他们一起同时做核酸检测。这种同时做核酸的操作，相当于同时去获取医生资源，咱们称之为共享锁。上面是咱们测试代码。
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* _@author_ ：__jiaolian
* _@date_ ：__Created in 2021-01-21 19:54
* _@description__：共享锁测试_
* _@modified_ By__：
* _公众号__:__叫练_
*/
public class SharedLockTest {
**private** **static** `ReentrantReadWriteLock lock =` **new** `ReentrantReadWriteLock();` **private** **static** `ReentrantReadWriteLock.ReadLock readLock = lock.readLock();` _//__医院_ **private** **static** **class** **Hospital** `{` **private** `String name;` **public** **Hospital**(String name) `{` **this**`.name = name;` } _//__核酸检测排队测试_ **public** **void** **checkUp**() `{` **try** `{` readLock.lock(); `System.out.println(Thread.currentThread().getName()+`"正在做核酸检测"`);` _//__核酸过程__...__好受__..._ `Thread.sleep(`3000`);` `}` **catch** `(InterruptedException e) {` e.printStackTrace(); `}` **finally** `{` readLock.unlock(); } } } **public** **static** **void** **main**(String[] args) **throws** InterruptedException `{` `Hospital hospital =` **new** `Hospital(`"南京市第一医院"`);` `Thread JLWife =` **new** `Thread(()->hospital.checkUp(),`"叫练妻"`);` JLWife.start(); _//__睡眠__100__毫秒是让一家三口是有程序的排队去检测_ `Thread.sleep(`100`);` `Thread JLSon =` **new** `Thread(()->hospital.checkUp(),`"叫练子"`);` JLSon.start(); _/*Thread.sleep(100);_Thread JL = new Thread(()->hospital.checkUp(),”__叫练__”);
JL.start();*/
}`}`下面代码咱们用 ReentrantReadWriteLock.ReadLock 作为读锁，在主线程启动“叫练妻”和“叫练”两个线程，原本母子俩一共须要 6 秒能力实现友链交易的事件，当初只须要 3 秒就能够做完，共享锁益处是效率比拟高。如下图，是 AQS 外部某一时刻 Node 节点状态。比照上图，Node的状态变为了共享状态，这些节点能够同时去共享医生资源！
synchronized 锁不响应中断
/**
* _@author_ ：__jiaolian
* _@date_ ：__Created in 2020-12-31 18:17
* _@description__：__sync__不响应中断_
* _@modified_ By__：
* _公众号__:__叫练_
*/
public class SynchronizedInterrputedTest {
**private** **static** **class** **MyService** `{` **public** **synchronized** **void** **lockInterrupt**() `{` **try** `{` `System.out.println(Thread.currentThread().getName()+`"获取到了锁"`);` **while** `(`**true**`) {` _//System.out.println();_ } `}` **catch** `(Exception e) {` e.printStackTrace(); } } } **public** **static** **void** **main**(String[] args) **throws** InterruptedException `{` `MyService myService =` **new** `MyService();` _//__先启动线程__A__，让线程__A__先领有锁_ `Thread threadA =` **new** `Thread(()->{` myService.lockInterrupt(); }); threadA.start(); `Thread.sleep(`1000`);` _//__启动线程__B__，中断，__synchronized__不响应中断！_ `Thread threadB =` **new** `Thread(()->{` myService.lockInterrupt(); }); threadB.start(); `Thread.sleep(`1000`);` threadB.interrupt(); }`}`如上述代码：先启动 A 线程，让线程 A 先领有锁，睡眠 1 秒再启动线程 B 是让 B 线程处于可运行状态，隔 1 秒后再中断 B 线程。在控制台输入如下：A 线程获取到了锁，期待 2 秒后控制台并没有立即输入报错信息，程序始终未完结执行，阐明 synchronized 锁不响应中断，须要 B 线程获取锁后才会输入线程中断报错信息！
AQS 响应中断
常常做比拟常识才会死记硬背，在 Lock 提供 lock 和 lockInterruptibly 两种获取锁的形式，其中 lock 办法和 synchronized 是不响应中断的，那上面咱们看看 lockInterruptibly 响应中断是什么意思。咱们还是用核酸案例阐明。
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* _@author_ ：__jiaolian
* _@date_ ：__Created in 2021-01-22 15:18
* _@description__：__AQS__响应中断代码测试_
* _@modified_ By__：
* _公众号__:__叫练_
*/
public class AQSInterrputedTest {
**private** **static** `ReentrantReadWriteLock lock =` **new** `ReentrantReadWriteLock();` **private** **static** `ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();` _//__医院_ **private** **static** **class** **Hospital** `{` **private** `String name;` **public** **Hospital**(String name) `{` **this**`.name = name;` } _//__核酸检测排队测试_ **public** **void** **checkUp**() `{` **try** `{` writeLock.lockInterruptibly(); `System.out.println(Thread.currentThread().getName()+`"正在做核酸检测"`);` _//__核酸过程__...__好受__..._ `Thread.sleep(`3000`);` `}` **catch** `(InterruptedException e) {` e.printStackTrace(); `}` **finally** `{` writeLock.unlock(); } } } **public** **static** **void** **main**(String[] args) **throws** InterruptedException `{` `Hospital hospital =` **new** `Hospital(`"南京市第一医院"`);` `Thread JLWife =` **new** `Thread(()->hospital.checkUp(),`"叫练妻"`);` JLWife.start(); _//__睡眠__100__毫秒是让一家三口是有程序的排队去检测_ `Thread.sleep(`100`);` `Thread JLSon =` **new** `Thread(()->hospital.checkUp(),`"叫练子"`);` JLSon.start(); `Thread.sleep(`100`);` `Thread JL =` **new** `Thread(()->hospital.checkUp(),`"叫练"`);` JL.start(); _//__期待__1__秒，中断叫练线程_ `System.out.println(`"护士小姐姐想和叫练私聊会!"`);` `Thread.sleep(`1000`);` JL.interrupt(); }`}`如上代码：叫练一家三口采纳的是独占锁排队去做核酸，叫练线程期待一秒后，护士小姐姐想和叫练私聊会！莫非小姐姐会有啥想法，于是叫练立即中断了这次的核酸检测，留神是 立即中断 。控制台打印后果如下：叫练妻线程和叫练子线程都做了核酸，但叫练却没有做胜利！因为被护士小姐姐中断了，后果如下图所示。所以咱们能得出结论，在 aqs 中锁是能够响应中断的。当初如果将上述代码中 lockInterruptibly 办法换成 lock 办法会产生什么状况呢，如果换成这种形式，小姐姐再来撩我，叫练要先胜利获取锁，也就说叫练曾经到医生旁边筹备做核酸了，小姐姐忽然说有事找叫练， 最终导致叫练没有做核酸 ，碰上这样的事，只能说小姐姐是居心的，小姐姐 太坏 了。对于 lock 办法不响应中断的测试大家能够本人测试下。看看我是不是 委屈 护士小姐姐了。
咱们能够得出结论：在 aqs 中如果一个线程正在获取锁或者处于期待状态，另一个线程中断了该线程，响应中断的意思是该线程立即中断，而不响应中断的意思是该线程须要获取锁后再中断。
条件队列
人生或者有那么些不如意。漫长的一个小时排队期待终于过来了，轮到咱们筹备做核酸了，你说 气不气，每次叫练妻出门都带身份证，可偏偏回家这次遗记了？咱们用代码看看叫练一家三口在做核酸的过程中到底产生了啥事件？又是怎么解决的！
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* _@author_ ：__jiaolian
* _@date_ ：__Created in 2021-01-22 16:10
* _@description__：条件队列测试_
* _@modified_ By__：
* _公众号__:__叫练_
*/
public class ConditionTest {
**private** **static** `ReentrantReadWriteLock lock =` **new** `ReentrantReadWriteLock();` **private** **static** `ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();` _//__条件队列_ **private** **static** `Condition condition = writeLock.newCondition();` _//__医院_ **private** **static** **class** **Hospital** `{` **private** `String name;` **public** **Hospital**(String name) `{` **this**`.name = name;` } _//__核酸检测排队测试_ **public** **void** **checkUp**(**boolean** isIdCard) `{` **try** `{` writeLock.lock(); validateIdCard(isIdCard); `System.out.println(Thread.currentThread().getName()+`"正在做核酸检测"`);` _//__核酸过程__...__好受__..._ `Thread.sleep(`3000`);` `}` **catch** `(InterruptedException e) {` e.printStackTrace(); `}` **finally** `{` writeLock.unlock(); `System.out.println(Thread.currentThread().getName()+`"核酸检测实现"`);` } } _//__校验身份信息__;_ **private** **void** **validateIdCard**(**boolean** isIdCard) `{` _//__如果没有身份信息，须要期待_ **if** `(!isIdCard) {` **try** `{` `System.out.println(Thread.currentThread().getName()+`"遗记带身份证了"`);` condition.await(); `}` **catch** `(InterruptedException e) {` e.printStackTrace(); } } } _//__告诉所有期待的人_ **public** **void** **singleAll**() `{` **try** `{` writeLock.lock(); condition.signalAll(); `}` **catch** `(Exception e) {` e.printStackTrace(); `}` **finally** `{` writeLock.unlock(); } } } **public** **static** **void** **main**(String[] args) **throws** InterruptedException `{` `Hospital hospital =` **new** `Hospital(`"南京市第一医院"`);` `Thread.currentThread().setName(`"护士小姐姐线程"`);` `Thread JLWife =` **new** `Thread(()->{` `hospital.checkUp(`**false**`);` `},`"叫练妻"`);` JLWife.start(); _//__睡眠__100__毫秒是让一家三口是有程序的排队去检测_ `Thread.sleep(`100`);` `Thread JLSon =` **new** `Thread(()->hospital.checkUp(`**true**`),`"叫练子"`);` JLSon.start(); `Thread.sleep(`100`);` `Thread JL =` **new** `Thread(()->{` `hospital.checkUp(`**true**`);` `},`"叫练"`);` JL.start(); _//__期待叫练线程执行结束_ JL.join(); hospital.singleAll(); }`}`如上代码：一家人获取独占锁须要排队检测，叫练妻先进去筹备核酸，护士小姐姐说先要刷身份证能力进去，叫练妻忽然回想起来，出门走得急身份证遗记带了，这可咋办，须要从新排队吗？叫练妻很恐慌，护士小姐姐说，要不这样吧，你先连忙回家拿，等叫练子，叫练先检测完，我就连忙安顿你进去在做核酸，那样你就不须要从新排队了，这就是上述这段代码的表白意思。咱们看看执行后果如下图，和咱们剖析的后果统一，下图最初画红圈的中央叫练妻最初实现核酸检测。上面咱们看看 AQS 外部经验的过程。
如下图，当叫练妻先获取锁，发现身份证忘带调用 await 办法会开释持有的锁，并把本人当做 node 节点放入条件队列的尾部，此时条件队列为空，所以条件队列中只有叫练妻一个线程在外面，接着护士小姐姐会将核酸医生这个资源开释调配给下一个期待者，也就是叫练子线程，同理，叫练子执行结束开释锁之后会唤醒叫练线程，底层是用 LockSupport.unpark 来实现唤醒的的操作，相当于根底系列里的 wait/notify/notifyAll 等办法。当叫练线程执行结束，前面没有线程了，护士小姐姐调用 singleAll 办法会见条件队列的叫练妻线程唤醒，并退出到 AQS 的尾部，期待执行。其中条件队列是一个单向链表，一个 AQS 能够通过 newCondition()对应多个条件队列。这里咱们就不独自用代码做测试了。
总结
明天咱们用代码 + 图片 + 故事的形式阐明了 AQS 重要的几个概念，整理出来心愿能对你有帮忙，写的比不全，同时还有许多须要修改的中央，心愿亲们加以斧正和点评，年前这段时间会持续输入实现 AQS 高级锁，如：ReentrantLock，线程池这些概念等。