Wait-Notify机制

叁歲伎倆 2024-02-19 09:18 32阅读 0赞

#### 文章目录 ####

*   *  1. 简介
     *  2. 相关API
     *  3. wait notify的正确姿势
     *  4. 总结

### 1. 简介 ###

回顾Minitor锁的结构：  
![在这里插入图片描述][af07220e2ed746c3bad59aa83764c227.png]

*  Owner线程发现条件不满足，调用wait方法，即可进入WaitSet变为WAITING状态
 *  BLOCKED和WAITING的线程都处于**阻塞状态**，不占用CPU时间
 *  BLOCKED线程会在Owner线程释放锁时唤醒
 *  WAITING线程会在Owner调用notify或notifyAll时唤醒，但唤醒后并不意味着立刻获得锁，仍需进入EntryList重新竞争

### 2. 相关API ###

1.  Obj.wait()：让进入object的Monitor的线程到WaitSet等待
2.  Obj.wait(long n)：有时限的等待，到n毫秒后结束等待，或者在n毫秒内被唤醒
3.  Obj.notify()：在object上正在waitSet等待的线程中挑哟个唤醒
4.  Obj.notifyAll()：让object上正在waitSet等待的线程全部被唤醒

### 3. wait notify的正确姿势 ###

*  sleep(long n)和wait(long n)的区别

> 1.  sleep是Thread的静态方法，而wait是Object的方法
> 2.  sleep不需要强制和synchronized配合使用，但wait需要
> 3.  sleep在睡眠的同时，不会释放对象锁，但wait在等待时会释放对象锁

*  step1

思考下面代码：

![在这里插入图片描述][f22deca51c0544409671c4f472e12896.png]  
问题是，小南线程在睡眠的时候，其它线程全部在EntryList中阻塞等待，在高并发场景下，这种效率是很低的，所以我们需要改善这种情况。

*  Step 2

使用wait-notify解决上面问题

![在这里插入图片描述][7c85bf4e5ce7444e9c67c250e4e9a952.png]  
上面代码初步解决了前面小南线程在等待烟的时候，所有等待room的线程都会阻塞的问题。但同时也引入了新的问题，假如不止小南线程在等待，还有其它线程在wait，那么送烟线程会错误的唤醒其它线程，而不是指定的小南线程

*  Step 3

@Slf4j
    public class jvm {
        
        static final Object room=new Object();
        static boolean hasCigarette=false;
        static boolean hasTakeout=false;
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(()->{
        
                synchronized (room){
        
                    log.debug("有烟没?[{}]",hasCigarette);
                    if(!hasCigarette){
        
                        try {
        
                            log.debug(("没烟，先歇一会!"));
                             room.wait();
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                    log.debug("有烟没?[{}]",hasCigarette);
                    if(hasCigarette){
        
                        log.debug("开始干活了!");
                    }else {
        
                        log.debug("这活干不了!");
                    }
                }
            },"小南").start();
            new Thread(()->{
        
                synchronized (room){
        
                    log.debug("外买到了没?[{}]",hasTakeout);
                    if(!hasTakeout){
        
                        try {
        
                            log.debug(("没外卖，先歇一会!"));
                            room.wait();
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                    log.debug("外买到了没?[{}]",hasTakeout);
                    if(hasTakeout){
        
                        log.debug("开始干活了!");
                    }else{
        
                        log.debug("这活干不了!");
                    }
                }
            },"小北").start();
            Thread.sleep(1000);
            new Thread(()->{
        
                synchronized (room){
        
                    hasTakeout=true;
                    log.debug("外卖到了哦！");
                    room.notify();
                }
            },"送外卖的").start();
        }
    }

![在这里插入图片描述][fae04335374748af806205a5c9c53699.png]  
从上面结果我们可以看出，外卖的线程唤醒了小南线程，这就出现了虚假唤醒的情况，那么怎么解决这个问题呢，我们使用notifyAll可以解决上面问题。

@Slf4j
    public class jvm {
        
        static final Object room=new Object();
        static boolean hasCigarette=false;
        static boolean hasTakeout=false;
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(()->{
        
                synchronized (room){
        
                    log.debug("有烟没?[{}]",hasCigarette);
                    if(!hasCigarette){
        
                        try {
        
                            log.debug(("没烟，先歇一会!"));
                             room.wait();
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                    log.debug("有烟没?[{}]",hasCigarette);
                    if(hasCigarette){
        
                        log.debug("开始干活了!");
                    }else {
        
                        log.debug("这活干不了!");
                    }
                }
            },"小南").start();
            new Thread(()->{
        
                synchronized (room){
        
                    log.debug("外买到了没?[{}]",hasTakeout);
                    if(!hasTakeout){
        
                        try {
        
                            log.debug(("没外卖，先歇一会!"));
                            room.wait();
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                    log.debug("外买到了没?[{}]",hasTakeout);
                    if(hasTakeout){
        
                        log.debug("开始干活了!");
                    }else{
        
                        log.debug("这活干不了!");
                    }
                }
            },"小北").start();
            Thread.sleep(1000);
            new Thread(()->{
        
                synchronized (room){
        
                    hasTakeout=true;
                    log.debug("外卖到了哦！");
                    room.notifyAll();
                }
            },"送外卖的").start();
        }
    }

![在这里插入图片描述][7e8c7cbb40064020baa71929adeb6f95.png]  
虽然我们解决了小北的问题，小南的问题我们还是没有解决，由于小南被外卖线程给唤醒了，但是却没有拿到烟，这是小南线程还是没干活，这就是新出现的问题。

*  Step 4

我们之前使用的if判断，如果我们改成while循环就解决了上面问题

@Slf4j
    public class jvm {
        
        static final Object room=new Object();
        static boolean hasCigarette=false;
        static boolean hasTakeout=false;
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(()->{
        
                synchronized (room){
        
                    log.debug("有烟没?[{}]",hasCigarette);
                    while(!hasCigarette){
        
                        try {
        
                            log.debug(("没烟，先歇一会!"));
                             room.wait();
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                    log.debug("有烟没?[{}]",hasCigarette);
                    if(hasCigarette){
        
                        log.debug("开始干活了!");
                    }else {
        
                        log.debug("这活干不了!");
                    }
                }
            },"小南").start();
            new Thread(()->{
        
                synchronized (room){
        
                    log.debug("外买到了没?[{}]",hasTakeout);
                    while(!hasTakeout){
        
                        try {
        
                            log.debug(("没外卖，先歇一会!"));
                            room.wait();
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                    log.debug("外买到了没?[{}]",hasTakeout);
                    if(hasTakeout){
        
                        log.debug("开始干活了!");
                    }else{
        
                        log.debug("这活干不了!");
                    }
                }
            },"小北").start();
            Thread.sleep(1000);
            new Thread(()->{
        
                synchronized (room){
        
                    hasTakeout=true;
                    log.debug("外卖到了哦！");
                    room.notifyAll();
                }
            },"送外卖的").start();
        }
    }

![在这里插入图片描述][2d180f5c995440759563e7fe53d34ad7.png]

> 到此为止我们解决了虚假唤醒的问题

### 4. 总结 ###

我们使用wait-notify的正确姿势应该如下：

synchronized(lock){
        
    	while(条件B不成立)
    	{
        
           lock.wait();
    	}
    	//代码逻辑
    }
    synchronized(lock){
        
    	lock.notifyAll();
    }

[af07220e2ed746c3bad59aa83764c227.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/0761e976c54d4585a13cc0ee221533ef.png
[f22deca51c0544409671c4f472e12896.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/9b184b727c2a4c6f93219aaf091661a2.png
[7c85bf4e5ce7444e9c67c250e4e9a952.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/bbc9647c633540b68e048a4fdc2989ba.png
[fae04335374748af806205a5c9c53699.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/b09455d14ded4f2bb18c90a169970820.png
[7e8c7cbb40064020baa71929adeb6f95.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/c3f5b31d77bb495db94015a41fc6e525.png
[2d180f5c995440759563e7fe53d34ad7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/65cb6296116c42f7b7899bb38d6ee910.png