春节越来越近了，疫情也越来越严重，但挡不住叫练携一家老小回老家（湖北）团聚的冲动。响应国家要求去我们做核酸检测了。
image.png

早上叫练带着一家三口来到了南京市第一医院做核酸检测，护士小姐姐站在医院门口拦着告诉我们人比较多，无论大人小孩，需要排队一个个等待医生采集唾液检测，OK，下面我们用代码+图看看我们一家三口是怎么排队的！

  1. import java.util.concurrent.locks.ReentrantReadWriteLock;
  3. /**
  4.  * @author ：jiaolian
  5.  * @date ：Created in 2021-01-22 10:33
  6.  * @description：独占锁测试
  7.  * @modified By：
  8.  * 公众号:叫练
  9.  */
  10. public class ExclusiveLockTest {
  12.     private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  14.     private static ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
  16.     //医院
  17.     private static class Hospital {
  19.         private String name;
  21.         public Hospital(String name) {
  22.             this.name = name;
  23.         }
  25.         //核酸检测排队测试
  26.         public void checkUp() {
  27.             try {
  28.                 writeLock.lock();
  29.                 System.out.println(Thread.currentThread().getName()+"正在做核酸检测");
  30.                 //核酸过程...难受...
  31.                 Thread.sleep(3000);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             } finally {
  35.                 writeLock.unlock();
  36.             }
  37.         }
  38.     }
  41.     public static void main(String[] args) throws InterruptedException {
  42.         Hospital hospital = new Hospital("南京市第一医院");
  43.         Thread JLWife = new Thread(()->hospital.checkUp(),"叫练妻");
  44.         JLWife.start();
  45.         //睡眠100毫秒是让一家三口是有顺序的排队去检测
  46.         Thread.sleep(100);
  47.         Thread JLSon = new Thread(()->hospital.checkUp(),"叫练子");
  48.         JLSon.start();
  49.         Thread.sleep(100);
  50.         Thread JL = new Thread(()->hospital.checkUp(),"叫练");
  51.         JL.start();
  52.     }
  53. }

如上代码：在主线程启动三个线程去医院门口排队，女士优先，叫练妻是排在最前面的，中间站的是叫练的孩子，最后就是叫练自己了。我们假设模拟了下核酸检测一次需要３秒。代码中我们用了独占锁，独占锁可以理解成医院只有一个医生，一个医生同时只能为一个人做核酸，所以需要逐个排队检测，所以代码执行完毕一共需要花费９秒，核酸检测就可以全部做完。代码逻辑还是比较简单，和我们之前文章描述synchronized同理。核酸排队我们用图描述下吧！
image.png

AQS全称是AbstractQueueSynchroniz，意为队列同步器，本质上是一个双向链表，在AQS里面每个线程都被封装成一个Node节点，每个节点都通过尾插法添加。另外节点还有还封装状态信息，比如是独占的还是共享的，如上面的案例就表示独占Node，医生他本身是一种共享资源，在AQS内部里面叫它state，用int类型表示，线程都会通过CAS的方式争抢state。线程抢到锁了，就自增，没有抢到锁的线程会阻塞等待时机被唤醒。如下图：根据我们理解抽象出来AQS的内部结构。
image.png
**根据上面描述，大家看AQS不就是用Node封装线程，然后把线程按照先来后到（非公平锁除外）连接起来的双向链表嘛！关于非公平锁我之前写《排队打饭》案例中也通过简单例子描述过。有兴趣童鞋可以翻看下！
**
**

上面我们做核酸的过程是同步执行的，叫独占锁。那共享锁是什么意思呢？现在叫练孩子只有3岁，不能独立完成核酸检测，护士小姐姐感同身受，观察叫练子是排在叫练妻后面的，就让他们一起同时做核酸检测。这种同时做核酸的操作，相当于同时去获取医生资源，我们称之为共享锁。下面是我们测试代码。

  1. import java.util.concurrent.locks.ReentrantReadWriteLock;
  3. /**
  4.  * @author ：jiaolian
  5.  * @date ：Created in 2021-01-21 19:54
  6.  * @description：共享锁测试
  7.  * @modified By：
  8.  * 公众号:叫练
  9.  */
  10. public class SharedLockTest {
  12.     private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  14.     private static ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
  16.     //医院
  17.     private static class Hospital {
  19.         private String name;
  21.         public Hospital(String name) {
  22.             this.name = name;
  23.         }
  25.         //核酸检测排队测试
  26.         public void checkUp() {
  27.             try {
  28.                 readLock.lock();
  29.                 System.out.println(Thread.currentThread().getName()+"正在做核酸检测");
  30.                 //核酸过程...难受...
  31.                 Thread.sleep(3000);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             } finally {
  35.                 readLock.unlock();
  36.             }
  37.         }
  38.     }
  41.     public static void main(String[] args) throws InterruptedException {
  42.         Hospital hospital = new Hospital("南京市第一医院");
  43.         Thread JLWife = new Thread(()->hospital.checkUp(),"叫练妻");
  44.         JLWife.start();
  45.         //睡眠100毫秒是让一家三口是有顺序的排队去检测
  46.         Thread.sleep(100);
  47.         Thread JLSon = new Thread(()->hospital.checkUp(),"叫练子");
  48.         JLSon.start();
  49.         /*Thread.sleep(100);
  50.         Thread JL = new Thread(()->hospital.checkUp(),"叫练");
  51.         JL.start();*/
  52.     }
  53.     
  54. }

上面代码我们用ReentrantReadWriteLock.ReadLock作为读锁，在主线程启动“叫练妻”和“叫练”两个线程，本来母子俩一共需要6秒才能完成的事情，现在只需要3秒就可以做完，共享锁好处是效率比较高。如下图，是AQS内部某一时刻Node节点状态。对比上图，Node的状态变为了共享状态，这些节点可以同时去共享医生资源！
image.png

  1. /**
  2.  * @author ：jiaolian
  3.  * @date ：Created in 2020-12-31 18:17
  4.  * @description：sync不响应中断
  5.  * @modified By：
  6.  * 公众号:叫练
  7.  */
  8. public class SynchronizedInterrputedTest {
  10.     private static class MyService {
  12.         public synchronized void lockInterrupt() {
  13.             try {
  14.                 System.out.println(Thread.currentThread().getName()+" 获取到了锁");
  15.                 while (true) {
  16.                    //System.out.println();
  17.                 }
  18.             } catch (Exception e) {
  19.                 e.printStackTrace();
  20.             }
  21.         }
  22.     }
  24.     public static void main(String[] args) throws InterruptedException {
  25.         MyService myService = new MyService();
  26.         //先启动线程A，让线程A先拥有锁
  27.         Thread threadA = new Thread(()->{
  28.             myService.lockInterrupt();
  29.         });
  30.         threadA.start();
  31.         Thread.sleep(1000);
  32.         //启动线程B，中断，synchronized不响应中断！
  33.         Thread threadB = new Thread(()->{
  34.             myService.lockInterrupt();
  35.         });
  36.         threadB.start();
  37.         Thread.sleep(1000);
  38.         threadB.interrupt();
  39.     }
  40. }

如上述代码：先启动A线程，让线程A先拥有锁，睡眠1秒再启动线程B是让B线程处于可运行状态，隔1秒后再中断B线程。在控制台输出如下：A线程获取到了锁，等待2秒后控制台并没有立刻输出报错信息，程序一直未结束执行，说明synchronized锁不响应中断，需要B线程获取锁后才会输出线程中断报错信息！
image.png

经常做比较知识才会融会贯通，在Lock提供lock和lockInterruptibly两种获取锁的方式，其中lock方法和synchronized是不响应中断的，那下面我们看看lockInterruptibly响应中断是什么意思。我们还是用核酸案例说明。

  1. import java.util.concurrent.locks.ReentrantReadWriteLock;
  3. /**
  4.  * @author ：jiaolian
  5.  * @date ：Created in 2021-01-22 15:18
  6.  * @description：AQS响应中断代码测试
  7.  * @modified By：
  8.  * 公众号:叫练
  9.  */
  10. public class AQSInterrputedTest {
  12.     private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  14.     private static ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
  16.     //医院
  17.     private static class Hospital {
  19.         private String name;
  21.         public Hospital(String name) {
  22.             this.name = name;
  23.         }
  25.         //核酸检测排队测试
  26.         public void checkUp() {
  27.             try {
  28.                 writeLock.lockInterruptibly();
  29.                 System.out.println(Thread.currentThread().getName()+"正在做核酸检测");
  30.                 //核酸过程...难受...
  31.                 Thread.sleep(3000);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             } finally {
  35.                 writeLock.unlock();
  36.             }
  37.         }
  38.     }
  41.     public static void main(String[] args) throws InterruptedException {
  42.         Hospital hospital = new Hospital("南京市第一医院");
  43.         Thread JLWife = new Thread(()->hospital.checkUp(),"叫练妻");
  44.         JLWife.start();
  45.         //睡眠100毫秒是让一家三口是有顺序的排队去检测
  46.         Thread.sleep(100);
  47.         Thread JLSon = new Thread(()->hospital.checkUp(),"叫练子");
  48.         JLSon.start();
  49.         Thread.sleep(100);
  50.         Thread JL = new Thread(()->hospital.checkUp(),"叫练");
  51.         JL.start();
  52.         //等待1秒，中断叫练线程
  53.         System.out.println("护士小姐姐想和叫练私聊会!");
  54.         Thread.sleep(1000);
  55.         JL.interrupt();
  56.     }
  57. }

如上代码：叫练一家三口采用的是独占锁排队去做核酸，叫练线程等待一秒后，护士小姐姐想和叫练私聊会！莫非小姐姐会有啥想法，于是叫练立刻中断了这次的核酸检测，注意是立刻中断。控制台打印结果如下：叫练妻线程和叫练子线程都做了核酸，但叫练却没有做成功！因为被护士小姐姐中断了，结果如下图所示。所以我们能得出结论，在aqs中锁是可以响应中断的。现在如果将上述代码中lockInterruptibly方法换成lock方法会发生什么情况呢，如果换成这种方式，小姐姐再来撩我，叫练要先成功获取锁，也就说叫练已经到医生旁边准备做核酸了，小姐姐突然说有事找叫练，最终导致叫练没有做核酸，碰上这样的事，只能说小姐姐是存心的，小姐姐太坏了。关于lock方法不响应中断的测试大家可以自己测试下。看看我是不是冤枉护士小姐姐了。
我们可以得出结论：在aqs中如果一个线程正在获取锁或者处于等待状态，另一个线程中断了该线程，响应中断的意思是该线程立刻中断，而不响应中断的意思是该线程需要获取锁后再中断。
image.png
image.png

人生或许有那么些不如意。漫长的一个小时排队等待终于过去了，轮到我们准备做核酸了，你说气不气，每次叫练妻出门都带身份证，可偏偏回家这次忘记了？我们用代码看看叫练一家三口在做核酸的过程中到底发生了啥事情？又是怎么处理的！

  1. import java.util.concurrent.locks.Condition;
  2. import java.util.concurrent.locks.ReentrantReadWriteLock;
  4. /**
  5.  * @author ：jiaolian
  6.  * @date ：Created in 2021-01-22 16:10
  7.  * @description：条件队列测试
  8.  * @modified By：
  9.  * 公众号:叫练
  10.  */
  11. public class ConditionTest {
  13.     private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  15.     private static ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
  17.     //条件队列
  18.     private static Condition condition = writeLock.newCondition();
  20.     //医院
  21.     private static class Hospital {
  23.         private String name;
  25.         public Hospital(String name) {
  26.             this.name = name;
  27.         }
  29.         //核酸检测排队测试
  30.         public void checkUp(boolean isIdCard) {
  31.             try {
  32.                 writeLock.lock();
  33.                 validateIdCard(isIdCard);
  34.                 System.out.println(Thread.currentThread().getName()+"正在做核酸检测");
  35.                 //核酸过程...难受...
  36.                 Thread.sleep(3000);
  37.             } catch (InterruptedException e) {
  38.                 e.printStackTrace();
  39.             } finally {
  40.                 writeLock.unlock();
  41.                 System.out.println(Thread.currentThread().getName()+"核酸检测完成");
  42.             }
  43.         }
  45.         //校验身份信息;
  46.         private void validateIdCard(boolean isIdCard) {
  47.             //如果没有身份信息，需要等待
  48.             if (!isIdCard) {
  49.                 try {
  50.                     System.out.println(Thread.currentThread().getName()+"忘记带身份证了");
  51.                     condition.await();
  52.                 } catch (InterruptedException e) {
  53.                     e.printStackTrace();
  54.                 }
  55.             }
  56.         }
  58.         //通知所有等待的人
  59.         public void singleAll() {
  60.             try {
  61.                 writeLock.lock();
  62.                 condition.signalAll();
  63.             } catch (Exception e) {
  64.                 e.printStackTrace();
  65.             } finally {
  66.                 writeLock.unlock();
  67.             }
  68.         }
  70.     }
  73.     public static void main(String[] args) throws InterruptedException {
  74.         Hospital hospital = new Hospital("南京市第一医院");
  75.         Thread.currentThread().setName("护士小姐姐线程");
  76.         Thread JLWife = new Thread(()->{
  77.             hospital.checkUp(false);
  78.             },"叫练妻");
  79.         JLWife.start();
  80.         //睡眠100毫秒是让一家三口是有顺序的排队去检测
  81.         Thread.sleep(100);
  82.         Thread JLSon = new Thread(()->hospital.checkUp(true),"叫练子");
  83.         JLSon.start();
  84.         Thread.sleep(100);
  85.         Thread JL = new Thread(()->{
  86.             hospital.checkUp(true);
  87.         },"叫练");
  88.         JL.start();
  89.         //等待叫练线程执行完毕
  90.         JL.join();
  91.         hospital.singleAll();
  92.     }
  94. }

如上代码：一家人获取独占锁需要排队检测，叫练妻先进去准备核酸，护士小姐姐说先要刷身份证才能进去，叫练妻突然回想起来，出门走得急身份证忘记带了，这可咋办，需要重新排队吗？叫练妻很恐慌，护士小姐姐说，要不这样吧，你先赶紧回家拿，等叫练子，叫练先检测完，我就赶紧安排你进去在做核酸，那样你就不需要重新排队了，这就是上述这段代码的表达意思。我们看看执行结果如下图，和我们分析的结果一致，下图最后画红圈的地方叫练妻最后完成核酸检测。下面我们看看AQS内部经历的过程。
image.png

如下图，当叫练妻先获取锁，发现身份证忘带调用await方法会释放持有的锁，并把自己当做node节点放入条件队列的尾部，此时条件队列为空，所以条件队列中只有叫练妻一个线程在里面，接着护士小姐姐会将核酸医生这个资源释放分配给下一个等待者，也就是叫练子线程，同理，叫练子执行完毕释放锁之后会唤醒叫练线程，底层是用LockSupport.unpark来完成唤醒的的操作，相当于基础系列里的wait/notify/notifyAll等方法。当叫练线程执行完毕，后面没有线程了，护士小姐姐调用singleAll方法会见条件队列的叫练妻线程唤醒，并加入到AQS的尾部，等待执行。其中条件队列是一个单向链表，一个AQS可以通过newCondition()对应多个条件队列。这里我们就不单独用代码做测试了。
image.png

今天我们用代码+图片+故事的方式说明了AQS重要的几个概念，整理出来希望能对你有帮助，写的比不全，同时还有许多需要修正的地方，希望亲们加以指正和点评，年前这段时间会继续输出实现AQS高级锁，如：ReentrantLock，线程池这些概念等。最后喜欢的请点赞加关注哦。我是叫练【公众号】，边叫边练。

注意：本故事是自己虚构出来的，仅供大家参考理解。希望大家过年都能顺利回家团聚！
tempImage1611306633088.gif

版权声明：本文为jiaolian原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/jiaolian/p/14319024.html