wait原理的讨论

Dear 丶 2024-04-08 09:51 78阅读 0赞

看到一篇关于`Synchorinzed`与`Lock`底层原理区别的文章，主要涉及两种锁的`EntryList`与`WaitSet`的区别、`wait`与`notify`的区别(严格说是二者阻塞与唤醒的区别)，前者从队尾唤醒，后者从队首唤醒，篇幅虽然长，但是讲解的非常清楚，仔细读，一定会有收获，学过的也会更加透彻，文章很宝贵，转载过来收藏(原文链接已在版权处标注，尊重原创，侵权删)~~

温馨提示：动图屏幕看不全的，可以点击打开，然后缩放浏览器

#### 正文开始 ####

*   *  1. 关于blocking状态的线程
     *   *  synchronized关键字的blocking
         *  ReentrantLock的Blocking
     *  2. waiting状态

![在这里插入图片描述][43baf589201148ec972126d833a91756.png]

**总结如下**：`synchronized`关键字的调用wait方法进入等到的线程和因为拿不到锁而等待线程是否同一种状态？`blocking`？`waiting`？

别小看这个问题，要扯清这个问题需要大篇幅的文字，所以再次长文警告；而且笔者可以很负责任的告诉读者如果你能看懂这篇文章绝对会燃起你对并发编程学习的兴趣

### 1. 关于blocking状态的线程 ###

#### synchronized关键字的blocking ####

在多线程编程的情况下，假设我们定义了一把锁，如果现在有10个线程来获取这把锁那么肯定只有第一个线程可以获取到锁，从而进入临界区（所谓临界区就是被锁保护起来的代码块）；其他获取不到锁的线程都会被阻塞（关于阻塞你就可以理解为`CPU`放弃调度这个线程了），但是这些被阻塞的线程`JVM`是怎么处理的呢？先看一张图  
![在这里插入图片描述][480702ea2a424dda86f721cb39bafe57.png]  
上图t1获取锁，如果在t1没有释放的情况下其他线程也来获取锁，结果肯定是获取不到，从而进入阻塞状态，但是这些被阻塞的线程如果不存某种关系将来唤醒的时候就很麻烦（比如先唤醒谁呢？有人肯定会说那肯定先唤醒最先阻塞的那个线程啊，关键是`JVM`如何知道哪个线程最先阻塞的呢？）为了解决这个麻烦`JVM`设计了一个`EntryList`的双向链表的队列来维护这些阻塞的线程；如上图这样`t2`到`tn`被维护到了这个队列，当`t1`释放锁之后会去这个队列当中唤醒一个线程来获取锁，这里请读者们思考一些问题；到底是唤醒一个，还是全部唤醒呢？如果唤醒一个是随机唤醒还是顺序唤醒，如果是顺序唤醒是正序还是倒序呢？笔者直接给出答案，当`t1`释放锁的时候会从`EntryList`当中唤醒一个线程，而且顺序唤醒，而且倒序的，也就是先唤醒tn这个线程；但是值得注意的`synchronized`关键字是倒序唤醒，但是如果你使用`ReentrantLock`那么则是正序唤醒；那么这个结论如何证明了----笔者将会通过2个角度来证明

1.  通过一个简单`java`应用来证明
2.  是通过`JDK`内部关于`ReentrantLock`锁的实现来证明；（因为`ReentrantLock`和`synchronized`关键字都是实现同步锁，他们都有这么一个队列，原理差不多，其实就算我能通过`ReentrantLock`来证明这个双向列表的队列真实存在也不能说明`synchronized`关键字也有这么一个队列啊，确实是这样，但是由于`ReentrantLock`的这个队列是java语言实现的，比较容易看懂，毕竟是母语啊，所以先看懂java语言级别的实现——`synchronized`关键字是没有`java`级别源码可看的，他是通过`C++`代码来实现的，先看懂`java`的实现再来看`C++`会轻松点）

首先来看一个简单的`java`应用，代码如下（先仔细阅读以下代码，下文我会对代码做解释，博客里面所有代码放到文末链接，读者可以自己下载）

package com.shadow.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "shadow")
    public class TestSynchronized {
        
        static List<Thread> list = new ArrayList<>();
        static Object lock = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            for (int i = 0; i < 10; i++) {
        
                Thread t = new Thread(() -> {
        
                    synchronized (lock) {
        
                        log.debug("thread executed");
                        try {
        
                            //这里的睡眠没有什么意义，仅仅为了控制台打印的时候有个间隔 视觉效果好
                            TimeUnit.MILLISECONDS.sleep(200);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }, "t" + i);//给每个线程去了一个名字 t1 t2 t3 ....
    
                list.add(t);
            }
    
            log.debug("---启动顺序 调度顺序或者说获取锁的顺序讲道理是正序0--9----");
         
            synchronized (lock) {
        
                for (Thread thread : list) {
        
                    //这个打印主要是为了看到线程启动的顺序
                    log.debug("{}-启动顺序--正序0-9", thread.getName());
                    thread.start();//  CPU 调度？
                    
                    //这个睡眠相当重要，如果没有这个睡眠会有很大问题
                    //这里是因为线程的start仅仅是告诉CPU线程可以调度了，但是会不会立马调度是不确定的
                    //如果这里不睡眠 就有有这种情况出现
                    // 主线程执行t1.start--Cpu没有调度t1--继续执行主线程t2-start cpu调度t2--然后再调度t1
                    //虽然我们的启动顺序是正序的（t1--t2），但是调度顺序是错乱的  t2---t1
                    
                    TimeUnit.MILLISECONDS.sleep(1);
                 }
                 log.debug("-------执行顺序--正序9-0");
            }
        }
    }

代码非常简单主线程`main`启动，然后实例化了10个线程对象`t0-t9`；继而把这个10个线程添加到一个`List`当中（注意这里仅仅是实例化了十（10）个线程，并没有启动，如果将来启动这10个线程他们的`run`方法里面的代码也非常简单，就是获取`lock`这把锁，然后打印一句话)；添加到数组之后`main`线程接着往下执行；`mian`线程获取锁（这里一定能获取成功，因为那10个线程还没启动，锁处于自由状态，所以能被`main`获取）；获取到锁之后`main`线程执行了一个`for`循环从`list`当中依次顺序获取到上面存入到`list`当中的那10个线程（由于`ArrayList`是有序的）故而取出的顺序肯定是有序的(`t0-t9`)；取出来之后依次调用star方法启动这些线程；但是这里需要注意的是虽然我们已经保证取出来的线程是顺序的（`t0-t9`），而且我们也保证了这些线程的`start`方法是顺序调用的，但是你依然没法保证这些线程的调度（也就是我们常说的执行）顺序；为了保证`t0-t9`的调度顺序我这里在线程`start`之后，让`main`线程`sleep`了1毫秒；这样就能保证`t0-t9`线程的调度或者说执行顺序；至于为什么要保证他们的调度顺序？

> 来解释一下为什么需要保证这个调度顺序呢?  
> 这里所有代码的意图就是顺序启动线程(顺序调度线程)，这些线程启动之后会去拿锁(lock)  
> 肯定拿不到，因为这个时候锁被主线程持有  
> 主线程还在for循环没有释放锁，所以在for循环里面启动的线程都是拿不到锁的  
> 那么这些那不到锁的线程就会阻塞  
> 也就t0----t9阳塞之后他们被存到了一个队列当中  
> 这个JVM的源码中可以证明，我后面给大家看源码，  
> 总之你现在记住所有拿不到锁的线程会阻塞进入到Entrylist这个队列当中  
> 然后主线程执行完for循环后会释放放锁  
> 继而会去这个队列当中去唤醒一个个线程————随机唤醒还是顺序唤醒呢?  
> 假设是顺序唤醒，是倒序还是正序唤醒呢?  
> 需要证明这个问题，就要保证所有因为拿不到锁而进入到这个队列当中的线程  
> 他们的顺序必须是有序的，这样后面从他们的执行结果才能分析；  
> 假设你 进入到阻塞队列的时候都是随机的，那么后面唤醒线程执行的时候必然也是随机的  
> 那么则无法证明唤醒是否具备有序性  
> 为了保证进入到队列当中的线程调度是有序的，主线程睡眠很有必要  
> 那么为什么主线程睡眠1下就能保证这些线程的顺序调度呢?这个问题读者可以思考一下后而我会重点分析  
> 好了现在我们来看结果

![在这里插入图片描述][066803f67a604408b025b02f54164cc7.gif_pic_center]  
从上图可以看出首先10个线程的启动顺序（由于主线程睡眠了1毫秒故而启动顺序其实等于调度顺序）是`t0-t9`；因为在启动线程的时候主线程没有释放锁，所以`t0-t9`都因为拿不到锁进入了队列(`EntryList`)，又因为`t0-t9`的调度（启动）顺序保证了，所以进入队列的顺序也保证了（`t0`先进入队列，`t9`最后进入队列）；但是在主线程释放锁的时候，唤醒线程的顺序是都倒序的，先唤醒`t9`，最后唤醒`t0`；这里的结果可以说明`JVM`在从队列当中唤醒的时候是唤醒一个，而不是全部唤醒，因为如果是全部唤醒，那么这些线程的执行顺序肯定是乱的，只有唤醒一个，而且还是顺序唤醒才能保证执行顺序是具备规则的（`t9-t0`），而且是倒序唤醒的；那么这队列存在哪里呢？在java语言里使用`synchronized`关键字如果变成了一把重量锁（关于什么是重量锁下次分析），那么这个锁对象（本文当中的`lock`对象——`Object lock = new Object()`）会关联一个`C++`对象——`ObjectMonitor`对象；这个监视器对象当中记录了持有当前锁的线程，记录了锁被重入的次数，同时他还有一个属性`EntryList`用来关联那些因为拿不到锁而被阻塞的线程；如下图所示(先不要关心`WaitSet`)  
![在这里插入图片描述][1260a68fe42e435b8035259a975ffbad.png]

#### ReentrantLock的Blocking ####

这次代码改一下，不用`synchronized`关键来保护临界区，而是换成`ReentrantLock`，代码如下

package com.shadow.test;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j(topic = "s")
    public class TestReentrantLock {
        
        
        static List<Thread> list = new ArrayList<>();
        //代码都没有变，只是把synchronized关键字变成了ReentrantLock
        static ReentrantLock lock = new ReentrantLock();
        public static void main(String[] args) throws InterruptedException {
        
            for (int i = 0; i < 10; i++) {
        
                Thread t = new Thread(() -> {
        
                    lock.lock();
                        log.debug("thread executed");
                        try {
        
                            TimeUnit.MILLISECONDS.sleep(200);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                   lock.unlock();
                }, "t" + i);
                list.add(t);
            }
            log.debug("---启动顺序 调度顺序或者说获取锁的顺序讲道理是正序0--9----");
            lock.lock();
                for (Thread thread : list) {
        
                    log.debug("{}-启动顺序--正序0-9", thread.getName());
                    thread.start();//  CPU 调度？
                    TimeUnit.MILLISECONDS.sleep(1);
                }
    
                log.debug("-------执行顺序--正序9-0");
    
            lock.unlock();
        }
    }

![在这里插入图片描述][6ff22dc404ca455e80378e515f90100a.gif_pic_center]  
从结果可以看到使用`ReentrantLock`来保护临界区的时候效果几乎和`synchronized`关键字相同，唯一不同的是当主线程释放锁之后去`EntryList`（`EntryList`其实是`C++`的队列，`ReentrantLock`其实不存在`EntryList`这个队列，但是他有一个对象`FairSync`或者`NonfairSync`这个对象维护了一个队列类似`EntryList`,文中为了方便都称之为`EntryList`吧）当中唤醒线程的时候是正序的（先进先出从）；由于`ReentrantLock`是用`java`语言实现的，可以通过查阅`JDK`源码来看看他的原理；`synchronized`需要查询`JVM`的`C++`源码；如果大家对并发编程感兴趣可以给我留言，我会持续更新，看有么有机会来写一篇关于`synchronized`关键的底层`C++`代码实现；好了现在我们来翻翻`JDK`源码中对`ReentrantLock`的源码实现吧（其实，笔者早先写过一篇关于`ReentrantLock`的源码实现，而且你可以去b站`search`关键字"子路 `AQS`"有视频版的`AQS`源码分析），这里不做特别细致的源码分析，只做简单的源码分析；

首先看一下`Node`类设计，由于Node类是`AbstractQueuedSynchronizer`的一个内部类，我没有截取到类名，只截取到父类的名字（`JDK`源码中`Node`主要用来封装线程，因为`node`类里面有一个属性就是`Thread`类型的，你可以理解一个`node`对象就是一个线程）  
![在这里插入图片描述][a9ff1c7c0182454282ea79f30aca6b78.png]  
主要关心三个属性

Node  prev    双向列表用来指向上一个node（也就是上一个线程）
    Node  next    双向链表用来指向下一个node(也就是下一个线程)
    Thread thread  当前node所封装的线程

如果单纯看这三个属性，可以理解`Node`类主要是为了线程之间有关联而设计的，因为如果没有这个`Node`那么单独一个`Thread`是很难描述清楚线程之间的关系的；比如上面代码中`t0-t9`他们的阻塞顺序靠一个`Thread`是很难表示的；有了这个`Node`就很好表示了，比如`node0`对象当中的`thread=t0，prev=null；next=node1；`而`node1`当中的`thread=t1，prev=node0，next=node2…`以此类推吧（实际当中`Node`类有很多属性的，这里不做讨论）；

再来看`AQS`这个同步框架最核心的类的设计；同样我们只关心他的几个属性  
![在这里插入图片描述][f654c3f03cc34c35b708d94bdca32b3a.png]

Node head	//队列当中的对头，也就是第一个阻塞的线程封装出来的node对象
    Node tail	//队列当中的对尾，也就是最后一个阻塞的线程封装出来的node对象
    int state	//锁的重入次数

如果我们使用`ReentrantLock`来保护临界区当一个线程拿不到锁的时候，会把这个线程封装成为一个`Node`对象；比如当`t7`来获取锁的时候则持有锁的线程是`main`，重入次数为1，对头为`t0`，队尾为`t6`；自己被封装成为一个`node`对象（此时还没有进入队列，也就是还没有关联之前）如下图(介于图片大小问题中间的`Node`忽略了，比如`t2`所代表的`node`，`t3`所代表的`node`)  
![在这里插入图片描述][f55dac9c32eb4a65aa4331d6b704258c.png]  
当封装好`t7`之后，这个时候t7所代表的`node`会进入到队列，进入队列之后如下图(介于图片大小问题中间的`Node`忽略了，比如`t2`所代表的`node`，`t3`所代表的`node`)  
![在这里插入图片描述][cccf8b9ffefd402899a4c8046dfcdea9.png]  
接下来通过`idea`当中的`debug`来说明一下上面的理论是否正确  
![在这里插入图片描述][b06936e6a7504ac3a81d56ffb67db5ee.gif_pic_center]  
上图的`debug`过程对于新手来说比较晦涩，可以多看几遍，或者文章末尾拿到笔者的代码自己去调试；主要需要说明的队列当中的对头关联并不是`t0`，而是一个`thread=null`，这个读者可以忽略（其实我在另一篇博客里面解释过了），也是就结果和我上面讲的有一些偏差，但是不影响，因为要解释这个`thread=null`代价比较大，读者可以把图换一下就一模一样了（实际情况如下图）  
![在这里插入图片描述][1d0127c915ee483e9d36fadb861414d5.png]  
`ReentrantLock`当中的这个`AQS`双向链表队列相当于`synchronized`关键字当中的那个`EntryList`双向链表队列；只不过`ReentrantLock`这个队列是先进先出，而`EntryList`则相反是先进后出；这个上面已经通过例子证明了；

其实`ReentrantLock`的先进先出可以通过源码来说明的；我们可以看看他的解锁方法也就是`unlock`方法看他如何唤醒线程的就真相大白了；  
![在这里插入图片描述][40df45d789bb40a185a6b214f3e6a4b4.gif_pic_center]  
好了说了这么多最后给大家总结一下

> 不管是synchronized还是使用ReentrantLock来做同步，并发情况下  
> 所有拿不到锁的线程都会进入一个双向链表去阻塞  
> 而进入这个队列当中阻塞的线程的状态就是blocking状态  
> 至于什么是waiting状态呢？  
> 同样我会通过synchronized和ReentrantLock两个技术点来说明

### 2. waiting状态 ###

首先我们假设这样一个场景`jack`是您们公司的一名程序员，他由于经常看笔者的博客；故而水平非常的高，经常能解决一些核心问题，所以逼格也很高；而各位读者就是程序员`x`，水平比较低，几乎没有逼格；假设你们老板在周末休息时间打电话叫所有程序员来加班，公司钥匙只有一把（进入到公司的人会把门锁了），所以能进到公司一定需要这把钥匙；这个时候`jack`来了，但是前面说过`jack`逼格很高他加班必须要你们老板给他安排一个女人，他才会啪啪啪（当然这里的啪啪啪是指敲键盘），不然他就会去休息，而你们是没有逼格的，进到公司就写代码；（有么有一点感同身受啊），基于这个场景我们来编程

package com.shadow.test;
    
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "s")
    public class TestWait1 {
        
    
        static  Object object = new Object();//锁对象
        static boolean isWoman = false; // 是否有女人
    
        public static void main(String[] args) {
        
            new Thread(() -> {
        //jack
                synchronized (object){
        
                    while (!isWoman){
        //判断是否有女人
                        log.debug("没有女人 我去等待老板安排 先休息，安排好之后叫醒我");
                        try {
        
                            TimeUnit.SECONDS.sleep(1000000);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("开始工作啪啪啪啪");
                }
            }, "jack").start();
    
    
            for (int i = 0; i <5 ; i++) {
        
                new Thread(() -> {
        
                    synchronized (object){
        
                        log.debug("那些默默无闻的程序员coding");
                    }
                }, "程序员"+i).start();
            }
        }
    
    }

代码其实很简单，就是`jack`先获取到锁，然后发觉没有女人，不能啪啪啪（再次强调这里的啪啪啪指的是敲键盘）；然后他就去休息了；然后其他彩笔程序员（`for i=5`）由于获取不到锁而不能工作无法启动；结果如下图  
![在这里插入图片描述][6a4e0f7f46b34904b94a51881bde7094.gif_pic_center]  
这样显然不合理，因为`jack`的女人问题，搞得其他五个人无法工作，可能被`fire`，这像极了我们平时，老板叫加班不敢不去，如果因为`jack`去不成那基本要被人事约谈，所以不合理；不合理的地方在于`jack`调用了`sleep`去阻塞，`sleep`阻塞的线程是无法释放锁的；假设有一种API能够让线程阻塞，同时又把锁释放了那就最好，`jack`他牛逼他去休息等女人，不影响其他人受虐心甘情愿的加班。`JDK`当中对于`synchronized`关键提供了一个`wait`方法可以实现上述功能

把代码修改一下，把`sleep`改成`wait`

package com.shadow.test;
    
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "s")
    public class TestWait1 {
        
    
        static  Object object = new Object();//锁对象
        static boolean isWoman = false; // 是否有女人
    
        public static void main(String[] args) {
        
            new Thread(() -> {
        //jack
                synchronized (object){
        
                    while (!isWoman){
        //判断是否有女人
                        log.debug("没有女人 我去等待老板安排 先休息，安排好之后叫醒我");
                        try {
        
                            
                            //jack线程进入阻塞，但是释放了锁
                            object.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("开始工作啪啪啪啪");
                }
            }, "jack").start();
    
    
            for (int i = 0; i <5 ; i++) {
        
                new Thread(() -> {
        
                    synchronized (object){
        
                        log.debug("那些默默无闻的程序员coding");
                    }
                }, "程序员"+i).start();
            }
        }
    
    }

再次运行，其他五个人可以工作了，而`jack`则在等待女人（`JVM`没有退出，因为`jack`线程阻塞了）  
![在这里插入图片描述][80a7b7ac72004beda67d3abda494d256.gif_pic_center]  
但是五个彩笔只能写`CRUD`关键高并发的核心代码还是得jack来啊，如果他休息项目基本要黄；故而老板没有办法只能满足他——找个女人来，找个桥本有菜来给jack（这就是大神和你的区别吧可能）；难么找来之后怎么唤醒jack呢？`jdk`当中提供了`notify/notifyall`来唤醒因为`wait`方法而被阻塞的线程

把代码再次改一下，添加一个`boos`线程，来满足`jack`的条件让`isWoman=true`，然后调用`notifyAll`来唤醒`jack`，叫醒之后`jack`啪啪啪完之后全部线程结束，`JVM`退出

package com.shadow.test;
    
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "s")
    public class TestWait1 {
        
    
        static  Object object = new Object();//锁对象
        static boolean isWoman = false; // 是否有女人
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        //jack
                synchronized (object){
        
                    while (!isWoman){
        //判断是否有女人
                        log.debug("没有女人 我去等待老板安排 先休息，安排好之后叫醒我");
                        try {
        
    
                            //jack线程进入阻塞，但是释放了锁
                            object.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("开始工作啪啪啪啪");
                }
            }, "jack").start();
    
    
            for (int i = 0; i <5 ; i++) {
        
                new Thread(() -> {
        
                    synchronized (object){
        
                        log.debug("那些默默无闻的程序员coding");
                    }
                }, "程序员"+i).start();
            }
    
    
    
            //这里睡眠主要是为了视觉效果，没什么意义
            //5s之后叫醒jack
            TimeUnit.SECONDS.sleep(5);
            new Thread(() -> {
        //jack
                synchronized (object){
        
                   isWoman=true;
                   log.debug("jack 桥本有菜来了，你可以啪啪啪了");
                   object.notifyAll();
                }
            }, "boss").start();
    
        }
    }

![在这里插入图片描述][50d74435f7c348188fbf50f464925670.gif_pic_center]  
现在随着你们项目的推进代码越来越多，`jack`肾再好也啪不动了，故而你们老板再请了一个同样经常看笔者博客的大神——女程序员`rose`；`rose`由于经常给我的博客点赞水平`比jack`还牛逼，自然逼格更高，他如果加班则需要加班费，否则也是不会干活去休息。于是再改下代码（为了简单我把另外五个线程的代码注释了）

package com.shadow.test;
    
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "s")
    public class TestWait1 {
        
    
        static  Object object = new Object();//锁对象
        static boolean isWoman = false; // 是否有女人
        static boolean isMoney = false; // 是否加钱了
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        //jack
                synchronized (object){
        
                    while (!isWoman){
        //判断是否有女人
                        log.debug("没有女人 我去等待老板安排 先休息，安排好之后叫醒我");
                        try {
        
    
                            //jack线程进入阻塞，但是释放了锁
                            object.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("开始工作啪啪啪啪");
                }
            }, "jack").start();
    
    
    
    
            new Thread(() -> {
        
                synchronized (object){
        
                    while (!isMoney){
        
                        log.debug("没有加钱，先休息不干活");
                        try {
        
                            object.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("干活了----有钱能使鬼推");
                }
            }, "rose").start();
    
    
    //        for (int i = 0; i <5 ; i++) {
        
    //            new Thread(() -> {
        
    //                synchronized (object){
        
    //                    log.debug("那些默默无闻的程序员coding");
    //                }
    //            }, "程序员"+i).start();
    //        }
    
    
    
            //这里睡眠主要是为了视觉效果，没什么意义
            //5s之后叫醒jack
            TimeUnit.SECONDS.sleep(5);
            new Thread(() -> {
        //jack
                synchronized (object){
        
                   isWoman=true;
                   log.debug("jack 桥本有菜来了，你可以啪啪啪了");
                   object.notifyAll();
                }
            }, "boss").start();
    
        }
    
    }

上面代码你们老板并没有加钱只是找了女人，但是调用了`notifyAll`把所有因为`wait`方法而阻塞的线程全部叫醒了，但是只有`jack`会工作——因为满足了女人条件。但是没有满足加钱条件所以`rose`还是不会工作会一直阻塞——`JVM`不会退出；  
![在这里插入图片描述][92f0064d334e42619fab1f94af7037a1.gif_pic_center]  
当然老板如果把`isMoney=true`那么`rose`也会干活，并且干活完成之后`JVM`也会正常结束，这个笔者就不在演示了；  
这里读者可以思考一个问题，因为老板调用的是`notifyAll`故而把所有线程叫醒了(`jack`和`rose`)，但是如果老板调用的是`notify`(只会叫醒一个)，那么老板叫醒的是谁呢？假设叫醒的是`jack`还好说，因为本身只满足了女人的条件叫醒他不为过，但是如果叫醒一个——刚好叫醒的是`rose`，而`rose`发现条件不满足继续`wait`，此时`jack`也在`wait`这样就不合理了，明明老板找来了桥本有菜，可是因为叫醒的人不对从而导致没有人工作，这下老板不是亏大了？（据我所知桥本有菜很贵的）；那么`notify`的叫醒规则是什么呢？关于这个问题笔者下次更新吧；其实这也是`synchronized`关键字`wait`的一个缺陷；在`ReentrantLock`当中这个问题得到了完美解决；`ReentrantLock`当中也提供了类似`wait`的功能叫做`Condition`，和`wait`不同是`Condition`可以有多个休息室，比如因为女人而`wait`的`jack`可以进入`A`休息室，而因为加钱而`wait`的`rose`可以进入`B`休息室（当然你也可以让`rose`也进入A休息室）；这样当条件满足的时候可以根据条件叫醒不同休息室的人；`synchronized`的`wait`方法是让线程进入一个队列`WaitSet`(休息室)，不管你是因为女人还是因为加钱——jack和rose都进入`WaitSet`队列（同一个休息室，因为`synchronized`只有一个休息室）；  
![在这里插入图片描述][e5f7011f98e2436d82406d381e6b9e47.png]  
因为拿不到锁而阻塞的线程(`t0-t9`)会进入`EntryList`阻塞；因为某个条件不满足被`wait`之后的线程进入`WaitSet`队列阻塞；那么为什么`JVM`不让`wait`的线程直接进入到`EntryList`当中呢？而是还要设计出来一个`WaitSet`的队列出来专门存放`wait`的线程呢？  
其实主要是因为如果都存放在`EntryList`当中那么`JVM`是无法区分这些线程是为什么而被阻塞的；而且将来唤醒的时候也无法确定该不该唤醒；试想这么一个场景，`t0`持有锁，`t1`是因为拿不到锁而阻塞进入`EntryList`当中阻塞，`t2`早先持有锁，因为某个条件不满足调用了`wait`也进入到`EntryList`当中阻塞(这里我们假设`JVM`把所有阻塞的线程都放到`EntryList`当中)；那么当`t0`释放锁之后讲道理他应该自动唤醒一个线程的，假设现在他唤醒的是`t2`就不合理啊，因为`t2`是`wait`而阻塞的不能自动唤醒，需要`notify`唤醒；所以`JVM`需要再设计一个`waitSet`来存放因为条件不满足调用了`wait`而阻塞的线程；

那么所有存在`waitSet`当中的线程状态就称之为`waiting`状态；现在如果你搞清楚了`waiting`和`blocking`那么接下来还有一个比较难的问题；所有`waiting`状态的线程必须经过`blocking`状态才能进入`runing`状态怎么理解？也就是一个`waiting`状态的线程是无法直接运行的，需要从`waiting`转换成`blocking`状态才能运行；说白了就是你调用`notifyAll`其实是把`waitset`当中所有阻塞线程转移到`EntryList`当中，然后当持有锁的线程释放锁之后再去`EntryList`当中的末尾（`synchronized`是末尾，`ReentrantLock`是最前面）唤醒一个执行；画幅图说明一下

现在持有锁的是main，假设`t0-t9`是`blocking`，`jack`和`rose`是`waiting`则如下图所示  
![在这里插入图片描述][8b08c5d5f65244438ddec98cd9b3eb91.png]  
如果现在主线程调用`notifyAll`方法会唤醒`jack`和`rose`，这里的唤醒其实是把它们转移到`EntryList`末尾，如下图所示  
![在这里插入图片描述][a3c30991d08541beb8fa3cf369e0685e.png]  
那么这个究竟是我吹牛逼还是真的如此呢？我通过一个例子和源码来证明  
首先看一个简单的`java`例子

package com.shadow.test;
    import lombok.extern.slf4j.Slf4j;
    import org.omg.CORBA.TIMEOUT;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "s")
    public class TestWait2 {
        
    
        static  Object object = new Object();//锁对象
        static boolean isWoman = false; // 是否有女人
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        //jack
                synchronized (object){
        
                    while (!isWoman){
        //判断是否有女人
                        log.debug("没有女人 我去等待老板安排 先休息，安排好之后叫醒我");
                        try {
        
                            //jack线程进入阻塞，但是释放了锁
                            object.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("开始工作啪啪啪啪");
                }
            }, "jack").start();
    
    
            TimeUnit.SECONDS.sleep(1);
    
            log.debug("1s之后主线程获取锁");
            log.debug("因为jack wait释放了锁，主线程能够获取到");
             log.debug("-----------关键看打印顺序----------------");
            synchronized (object) {
        
               
                for (int i = 0; i < 5; i++) {
        
                    new Thread(() -> {
        
                        synchronized (object) {
        
                            log.debug("那些默默无闻的程序员coding");
                        }
                    }, "t" + i).start();
                    TimeUnit.MILLISECONDS.sleep(1);
                }
    
                isWoman=true;
                object.notifyAll();
            }
    
    
        }
    
    }

解释一下代码，首先`jack`获取到了锁，然后调用了`wait`方法进入了`waitSet`阻塞，跟着主线程获取了锁，主线程获取锁之后启动了5个线程`(t0-t4)`；这5个线程也要获取锁，但是因为现在锁被主线程持有所以这五个线程肯定是获取不到锁的，继而进入`EntryList`阻塞；启动完5个线程之后主线程满足条件`isWoman=true;`从而唤醒`jack`，如果`jack`是即时唤醒执行的话，那么打印的顺序肯定是`jack`先执行（诚然结果也是`jack`先执行，但是其实这并不能说明`notifyAll`是即时唤醒），然后是`t4-t0`执行；但是笔者讲过`notifyAll`其实是转移线程到`EntryList`，也就是说当主线程调用完`object.notifyAll()`;之后`EntryList`当中应该存在6个线程`t0、t1、t2、t3、t4、jack`，如下图所示

**在没有调用notifyAll之前**  
![在这里插入图片描述][2c97941296d749cbab0260c6165c69ec.png]

**调用完notifyAll之后**  
![在这里插入图片描述][82873336f74c472eb3d498df98e7ef1c.png]  
主线程在调用完`notifyAll`之后就释放了锁，在这个时候`JVM`会去`EntryList`当中的末尾唤醒一个线程就是`jack(`这个上面我们已经证明过了——倒序)；所以打印的结果应该是`jack–>t4–>-t3—>t2---->t1—>t0`；  
![在这里插入图片描述][868c80d3b3b840288486c6b14d1d4e97.gif_pic_center]  
但是这其实不能说明问题，因为诚如我上文说的`notifyAll`如果是即时唤醒也是这个打印顺序；但是如果改下代码就能看出问题了，把唤醒`jack`放到启动五个线程前面；

package com.shadow.test;
    
    
    import lombok.extern.slf4j.Slf4j;
    import org.omg.CORBA.TIMEOUT;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "s")
    public class TestWait2 {
        
    
        static  Object object = new Object();//锁对象
        static boolean isWoman = false; // 是否有女人
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        //jack
                synchronized (object){
        
                    while (!isWoman){
        //判断是否有女人
                        log.debug("没有女人 我去等待老板安排 先休息，安排好之后叫醒我");
                        try {
        
    
                            //jack线程进入阻塞，但是释放了锁
                            object.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("开始工作啪啪啪啪");
                }
            }, "jack").start();
    
    
            TimeUnit.SECONDS.sleep(1);
    
            log.debug("1s之后主线程获取锁");
            log.debug("因为jack wait释放了锁，主线程能够获取到");
            log.debug("-----------关键看打印顺序----------------");
            synchronized (object) {
        
    
               ------------------------------------- //注意顺序换了------------------------
                isWoman=true;
                object.notifyAll();
    
    
                for (int i = 0; i < 5; i++) {
        
                    new Thread(() -> {
        
                        synchronized (object) {
        
                            log.debug("那些默默无闻的程序员coding");
                        }
                    }, "t" + i).start();
                    TimeUnit.MILLISECONDS.sleep(1);
                }
    
    
            }
    
    
        }
    
    }

那么情况就不同了如下图  
![在这里插入图片描述][e6a0529205904137b4ec5cccd9adf6dc.png]  
那么执行顺序也就变了，`jack`的执行应该在最后(`synchronized`是倒序的)；  
![在这里插入图片描述][dc5ab3d99c1c4d7296354b15fbf4fb01.gif_pic_center]  
这样应该足以证明问题了吧；假设你还不信，那么可以来翻阅`JDK`源码来证明这个问题，当然咯翻阅`JDK`源码主要是看`ReentrantLock`的实现，而不是`wait`的实现，`wait`的源码需要去看`JVM`源码`C++`代码；我们这里翻阅`JDK`源码只是来看看`ReentrantLock`当中的`Condition`是如何实现的，他几乎和`wait`的原理一样

把上面那个`jack`和`rose`加班的例子改一下，改成用`ReentrantLock`来实现(注意看代码)

package com.shadow.test;
    
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j(topic = "s")
    public class TestCondition1 {
        
    
        static ReentrantLock lock = new ReentrantLock();//锁对象
        static boolean isWoman = false; // 是否有女人
        static boolean isMoney = false; // 是否加钱了
        //因为钱不满足而进入阻塞的队列
        static Condition conditionMoney = lock.newCondition();
        //因为女人不满足而进入阻塞的队列
        static Condition conditionWoman = lock.newCondition();
    
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        //jack
                lock.lock();
                    while (!isWoman){
        //判断是否有女人
                        log.debug("没有女人 我去等待老板安排 先休息，安排好之后叫醒我");
                        try {
        
    
                            //jack线程进入阻塞，但是释放了锁
                            //进入特定的队列---conditionWoman
                           conditionWoman.await();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("开始工作啪啪啪啪");
               lock.unlock();
            }, "jack").start();
    
            new Thread(() -> {
        
               lock.lock();
                    while (!isMoney){
        
                        log.debug("没有加钱，先休息不干活");
                        try {
        
                            // 进入特定的队列---conditionWoman
                            conditionMoney.await();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("干活了----有钱能使鬼推");
                lock.unlock();
            }, "rose").start();
    
    
    
            TimeUnit.SECONDS.sleep(5);
            new Thread(() -> {
        //jack
                lock.lock();
                   isWoman=true;
                   log.debug("jack 桥本有菜来了，你可以啪啪啪了");
                   log.debug("因为是女人满足，从特定的队列当中（conditionWoman）唤醒");
                   conditionWoman.signalAll();
                lock.unlock();
            }, "boss").start();
    
        }
    }

这里定义了两个条件队列相当于定义了两个休息室，不同条件进入不同休息室，`jack`进入`conditionWoman`，而`rose`进入`conditionMoney`，老板最后只满足了桥本有菜故而只唤醒`jack——conditionWoman.signalAll();`rose是感觉不到的——甚至都不会醒来，刚刚`synchronized`关键字使用`wait`，调用`notifyAll`会把`rose`也叫醒，虽然`rose`最后还是去阻塞了(因为条件还是没有满足)，但是终究是被叫醒了一次；使用`ReentrantLock`就没有这个问题了  
![在这里插入图片描述][f221f66a43b743cfb9dd462321cb3655.gif_pic_center]  
自此可以知道`ReentrantLock`当中`Condition`可以实现和`synchronized`的`wait`一样的功能，而且她支持多条件，这比wait更加丰富(也是一个经典面试题——`ReentrantLock`和`synchronze`关键字的区别，什么情况下使用)，你可以从这个方面去回答的，当然他们的区别不止这些，有机会在讨论吧

关键他的源码是怎样呢？也就是调用`conditionWoman.await();`是否如我所说会进入到一个`waitSet`的队列？  
![在这里插入图片描述][3b4cf54e411140a28b9f3503e22b74fe.gif_pic_center]  
如果你有印象前面我们分析过所有因为拿不到锁的对象会进入到一个队列当中(ReentantLock当中的 FairSync这个对象所维护的双向链表队列)，但是这里调用`conditionWoman.await();`则线程进入的是ConditionObject这个对象所维护的双向链表队列；这里足可证明waiting和blokcing两种不同状态的线程是维护在不同队列的(需要注意的是waitSet和EntryList是C++中的说法，由于`ReentrantLock`是java语言实现的，故而`EntryList`对应是`ReentrantLock`当中公平锁或者非公平锁中的队列，WaitSet对应的是`ConditionObject`这个双向链表队列)；

再来看一下ReentrantLock的唤醒方法`conditionWoman.signalAll();`  
![在这里插入图片描述][105e08f21acf462d9e3d3c86592476a3.gif_pic_center]  
结论：调用signalAll或者notifyAll方法都是把waiting状态的线程转化成为blocking状态——因为JDK内部是完成了一个队列的转移，而不是即时唤醒执行

当然最后的最后我们再次来看看ReentrantLock的Condition被唤醒之后的调用顺序是怎样的

package com.shadow.test;
    
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j(topic = "s")
    public class TestConddition2 {
        
    
        static ReentrantLock lock = new ReentrantLock();//锁对象
        static boolean isWoman = false; // 是否有女人
        static Condition conditoon = lock.newCondition();
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        //jack
                lock.lock();
                    while (!isWoman){
        //判断是否有女人
                        log.debug("没有女人 我去等待老板安排 先休息，安排好之后叫醒我");
                        try {
        
    
                            //jack线程进入阻塞，但是释放了锁
                            conditoon.await();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("开始工作啪啪啪啪");
                lock.unlock();
            }, "jack").start();
    
    
            TimeUnit.SECONDS.sleep(1);
    
            log.debug("1s之后主线程获取锁");
            log.debug("因为jack wait释放了锁，主线程能够获取到");
            log.debug("-----------关键看打印顺序----------------");
            lock.lock();
    
    
    
                for (int i = 0; i < 5; i++) {
        
                    new Thread(() -> {
        
                       lock.lock();
                            log.debug("那些默默无闻的程序员coding");
                       lock.unlock();
                    }, "t" + i).start();
                    TimeUnit.MILLISECONDS.sleep(1);
                }
    
            //注意顺序换了------------------------
            isWoman=true;
            conditoon.signalAll();
            lock.unlock();
        }
    }

首先jack获取到了锁，然后调用了 conditoon.await();方法进入了waitSet（ConditionObject维护的双向链表）阻塞，然后主线程获取了锁，主线程获取锁之后启动了5个线程(t0-t4)；这5个线程也要获取锁，但是因为现在锁被主线程持有所以这五个线程肯定是获取不到锁的，继而进入EntryList（非公平锁或者公平锁维护的双向链表队列）阻塞；启动完5个线程之后主线程满足条件isWoman=true;继而唤醒jack因为jack是在五个线程之后被唤醒的，也就是最后进入队列的 t0、t1、t2、t3、t4、jack，所以按照ReentrantLock先进先出的规则jack最后执行(和synchronized相反，前面我们已经证明过了synchronized是jack先执行)  
![在这里插入图片描述][0547d53945db4ccfb2902fe3033c1860.gif_pic_center]  
代码地址(代码中用了lombok，自己装在idea)  
链接：https://pan.baidu.com/s/1djfBWmqotbUWimZ1ixFvMQ  
提取码：3v3u  
复制这段内容后打开百度网盘手机App，操作更方便哦

[43baf589201148ec972126d833a91756.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/fe04d9c91ff74f68b9882aa8f8a17e7b.png
[480702ea2a424dda86f721cb39bafe57.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/4c113eea32c6487e885e5e9938b7a8b5.png
[066803f67a604408b025b02f54164cc7.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/656a07cbeda948d69a40a07512d6d1e3.gif
[1260a68fe42e435b8035259a975ffbad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/0d78b46ec67f4a67986feb3111a60de2.png
[6ff22dc404ca455e80378e515f90100a.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/4ff7eab57ff4432893ba9752a7c896b4.gif
[a9ff1c7c0182454282ea79f30aca6b78.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/9d6f9e5641c242fdab70ffd5d2f47fd4.png
[f654c3f03cc34c35b708d94bdca32b3a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a5c239f6745449ea80c36cda6960ce1e.png
[f55dac9c32eb4a65aa4331d6b704258c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/21e003a8e7eb45cb8127fc6baad8404e.png
[cccf8b9ffefd402899a4c8046dfcdea9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5c9b033e9c8143fda5e31572bf87bef5.png
[b06936e6a7504ac3a81d56ffb67db5ee.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/fef2bccf0cf746a2ac0ccf810efb421d.gif
[1d0127c915ee483e9d36fadb861414d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5f12d818b4ce42a69cd433cd3432e653.png
[40df45d789bb40a185a6b214f3e6a4b4.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/073fb247d74d4fb0b56fb38d311fa4d3.gif
[6a4e0f7f46b34904b94a51881bde7094.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/2d5a92d1120e466c820a8022dca08efd.gif
[80a7b7ac72004beda67d3abda494d256.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/c69156dadf554e4994898d51c3dc21c2.gif
[50d74435f7c348188fbf50f464925670.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/bae25bfff4b348f8817c6bd90844455f.gif
[92f0064d334e42619fab1f94af7037a1.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a3c2a2a80ab44b52bdc9ff3aaf509ffe.gif
[e5f7011f98e2436d82406d381e6b9e47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/24a2b86ce2f340eb8cddb4a462b00a5f.png
[8b08c5d5f65244438ddec98cd9b3eb91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/b01c4d98ee46463782d7f9bfaccf5aaf.png
[a3c30991d08541beb8fa3cf369e0685e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/e43355a98c08429b819cfc761bd6de03.png
[2c97941296d749cbab0260c6165c69ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/3a93d3661068436882ea94b7edf03ed0.png
[82873336f74c472eb3d498df98e7ef1c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/d238c326c3fa4597953465abf341add0.png
[868c80d3b3b840288486c6b14d1d4e97.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/d3cbef6c6dfd474596383424131bdd24.gif
[e6a0529205904137b4ec5cccd9adf6dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/2ab86d62aff048809b12edcc1b985452.png
[dc5ab3d99c1c4d7296354b15fbf4fb01.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/d0b90db27e964e1e992bfb390b271b78.gif
[f221f66a43b743cfb9dd462321cb3655.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/4b984b258dae480baf1dfd2735f14b9f.gif
[3b4cf54e411140a28b9f3503e22b74fe.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/b3c948a25b134e5f9408978fd950814f.gif
[105e08f21acf462d9e3d3c86592476a3.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/2942ad8a2ac94d4e916bc77a38605021.gif
[0547d53945db4ccfb2902fe3033c1860.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/ae82695ce34e44d8bf7a5c84c38c94b9.gif