线程间的通信 wait、notify

ゝ一纸荒年。 2022-10-06 14:56 171阅读 0赞

上一篇：  
**[线程同步之synchronized关键字][synchronized]**

## wait ##

wait跟sleep方法的作用一样，也是让线程休眠，但是针对的对象不同。

*  **sleep**： sleep是Thread类中的静态方法，是直接作用于线程的，在哪个线程调sleep，哪个线程就休眠，而且可以随时调用。sleep方法执行期间**不会释放锁**，其他线程也必须要等待sleep执行完毕后才有机会进入同步代码中。
 *  **wait**： wait是Object类中的一个普通方法，通过对象调用。但是必须在持有该对象锁的同步代码中调用，否则会抛出异常。wait方法**会释放锁**，其他线程可以在wait期间进入同步代码中。

我们先来看看Object对象中的方法，本篇博客需要关心的就是以下红框中的几个方法。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70]

再来看看**wait**源码  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 1]

可以看到，最终调用了重载的 **wait(long timeout)**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 2]

我们先来简单用一用，看一下跟sleep的区别：

public static void main(String[] args) {
        
            Object o = new Object();
    
            for (int i = 0; i < 5; i++) {
        
                new Thread(() -> {
        
                    synchronized (o) {
        
    
                        System.out.println(Thread.currentThread().getName() + "开始执行");
                        try {
        
    
                            TimeUnit.SECONDS.sleep(2);
    //                        o.wait(2000);
                            System.out.println(Thread.currentThread().getName() + "被唤醒");
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + "执行完毕");
    
                    }
                }).start();
    
            }
    
        }

这里我们先在5个线程中的同步代码块中使用**sleep**看一下：  
![在这里插入图片描述][20210615144219705.gif]

同样的代码，把sleep改成wait试一下，这要注意wait方法必须要在持有对象锁的同步代码块中调用，也就是说你想调用o.wait,那么你必须先锁住o。

public static void main(String[] args) {
        
            Object o = new Object();
    
            for (int i = 0; i < 5; i++) {
        
                new Thread(() -> {
        
                    synchronized (o) {
        
    
                        System.out.println(Thread.currentThread().getName() + "开始执行");
                        try {
        
    
    //                        TimeUnit.SECONDS.sleep(2);
                            o.wait(2000);
                            System.out.println(Thread.currentThread().getName() + "被唤醒");
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + "执行完毕");
    
                    }
                }).start();
    
            }
    
        }

运行结果如下：  
![在这里插入图片描述][2021061514443086.gif]

对比两个运行结果，可以很明显的看出来，sleep是不会释放锁的，休眠期间其他线程必须等待锁被释放后才能执行，wait是会释放锁的，其他线程会在**wait**期间走进同步代码中。

上面我们是给wait指定了等待时间，当我们不给wait指定时间时，则线程会一直处于等待状态，直到调用了同一个对象锁的**notify**或**notifyAll**方法，才会继续执行。

示例代码：  
不给wait指定等待时间

public static void main(String[] args) {
        
            Object o = new Object();
    
            for (int i = 0; i < 5; i++) {
        
                new Thread(() -> {
        
                    synchronized (o) {
        
    
                        System.out.println(Thread.currentThread().getName() + "开始执行");
                        try {
        
                            o.wait();
                            System.out.println(Thread.currentThread().getName() + "被唤醒");
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + "执行完毕");
    
                    }
                }).start();
    
            }
    
        }

运行结果：  
![在这里插入图片描述][2021061514504599.gif]  
可以看到，后面一直都没执行。

## notify ##

源码注释太长，这里就不贴了。  
我们只需要记住，notify是用来唤醒正在等待的**单个**线程，如果同一把锁有多个线程都在等待，则随机唤醒其中一个。  
我们来简单用一用：

public static void main(String[] args) {
        
            Object o = new Object();
    
            for (int i = 0; i < 5; i++) {
        
                new Thread(() -> {
        
                    synchronized (o) {
        
    
                        System.out.println(Thread.currentThread().getName() + "开始执行");
                        try {
        
                            o.wait();
                            System.out.println(Thread.currentThread().getName() + "被唤醒");
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + "执行完毕");
    
                    }
                }).start();
    
            }
    
    
            /*让主线程休眠2秒钟*/
            try {
        
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            synchronized (o) {
        
                o.notify();
            }
    
        }

看一下运行结果：

![在这里插入图片描述][20210615150012877.gif]

可以看到，只有一条线程被唤醒了。

## notifyAll ##

notify是用来唤醒正在等待的**所有**线程，如果同一把锁有多个线程都在等待，则唤醒所有线程。

来用一把：

public static void main(String[] args) {
        
            Object o = new Object();
    
            for (int i = 0; i < 5; i++) {
        
                new Thread(() -> {
        
                    synchronized (o) {
        
    
                        System.out.println(Thread.currentThread().getName() + "开始执行");
                        try {
        
                            o.wait();
                            System.out.println(Thread.currentThread().getName() + "被唤醒");
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + "执行完毕");
    
                    }
                }).start();
    
            }
    
    
            /*让主线程休眠2秒钟*/
            try {
        
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            synchronized (o) {
        
                o.notifyAll();
            }
    
        }

运行结果如下：  
![在这里插入图片描述][20210615150317995.gif]

可以看到，所有wait的线程都被唤醒了。

实际上，Thread中的**join**方法底层调用的就是**wait**方法，join源码如下，join本身就是个同步方法。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 3]  
那join方法是什么时候会被唤醒呢？

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 4]  
通过注释可以知道，是在线程处于结束状态后就会被唤醒。

之前我们在 **[从Java线程到kotlin协程之线程合并 （join）][Java_kotlin_ _join]** 这篇文章中我们用join来实现两个接口

那这样一来，我们可以使用**wait**来达到跟**join**一样的效果，实现线程的同步。  
代码如下：

先来创建两个Runnable来模拟请求接口

/**
     * 模拟请求高德接口
     */
    class GaoDeRunnable implements Runnable {
        
        /*模拟的锁对象*/
        Object lock = null;
    
        /*接口返回的结果*/
        private String result = "";
    
        public GaoDeRunnable(Object lock) {
        
            this.lock = lock;
        }
    
        public String getResult() {
        
            return result;
        }
    
        public void setResult(String result) {
        
            this.result = result;
        }
    
        @Override
        public void run() {
        
            /*模拟请求高德接口*/
    
            synchronized (lock) {
        
                System.out.println("高德请求开始执行....");
                try {
        
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
    
    
                result = "gaodeResult";
    
                System.out.println("高德接口请求完毕,唤醒等待的线程");
    
                /*执行完毕  唤醒等待的线程*/
                lock.notifyAll();
            }
    
        }
    
    
    }
    
    
    /**
     * 模拟请求百度接口
     */
    class BaiDuRunnable implements Runnable {
        
        Object lock = null;
    
        private String result = "";
    
        public BaiDuRunnable(Object lock) {
        
            this.lock = lock;
        }
    
        public String getResult() {
        
            return result;
        }
    
        public void setResult(String result) {
        
            this.result = result;
        }
    
        @Override
        public void run() {
        
            /*模拟请求高德接口*/
    
            synchronized (lock) {
        
                System.out.println("百度请求开始执行....");
                try {
        
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
    
    
                result = "baiduResult";
    
                System.out.println("百度接口请求完毕,唤醒等待的线程");
    
                lock.notifyAll();
            }
    
        }
    
    
    }

两个代码逻辑都一样，休眠一段时间后，唤醒wait的线程。

main方法代码如下：

public static void main(String[] args) {
        
    
            /*高德 锁*/
            Object gaodeObjLock = new Object();
            /*百度 锁*/
            Object baiduObjLock = new Object();
    
            /*模拟请求高德接口的Runnable*/
            GaoDeRunnable gaoDeRunnable = new GaoDeRunnable(gaodeObjLock);
            /*模拟请求百度接口的Runnable*/
            BaiDuRunnable baiDuRunnable = new BaiDuRunnable(baiduObjLock);
    
            /*启动两个线程去执行*/
            new Thread(gaoDeRunnable).start();
            new Thread(baiDuRunnable).start();
    
            /*等待高德Runnable返回数据*/
            synchronized (gaodeObjLock) {
        
                while (gaoDeRunnable.getResult().isEmpty()) {
        
                    try {
        
                        gaodeObjLock.wait();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
                /*高德接口执行完毕*/
                System.out.println("高德接口执行完毕，获取的结果是：" + gaoDeRunnable.getResult());
    
            }
    
            /*等待百度Runnable返回数据*/
            synchronized (baiduObjLock) {
        
                while (baiDuRunnable.getResult().isEmpty()) {
        
                    try {
        
                        baiduObjLock.wait();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
    
    
                }
    
    
                /*高德接口执行完毕*/
                System.out.println("百度接口执行完毕，获取的结果是：" + baiDuRunnable.getResult());
            }
    
    
            System.out.println("两个接口都执行完毕了，最终的数据是：" + gaoDeRunnable.getResult() + "-----" + baiDuRunnable.getResult());
    
        }

下面来看看运行效果：

![在这里插入图片描述][20210615161311948.gif]

可以看到，运行结果跟之前使用**join**是一样的。

好了，wait方法就是这些

**[JUC以及并发，线程同步，线程安全的概念加深  
][JUC_]**

--------------------

**如果你觉得本文对你有帮助，麻烦动动手指顶一下，可以帮助到更多的开发者，如果文中有什么错误的地方，还望指正，转载请注明转自[喻志强的博客][Link 1] ，谢谢！**

[synchronized]: https://blog.csdn.net/yuzhiqiang_1993/article/details/117878205
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70]: /images/20221005/8ee3f58ba1b24441b9f19743ebf101d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 1]: /images/20221005/0ac974688e624e8f83d5250bcf14f5e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 2]: /images/20221005/03b47a670f8c46f1b2e29748acb1c04f.png
[20210615144219705.gif]: /images/20221005/cad3399806dd428798bf26af04c0c954.png
[2021061514443086.gif]: /images/20221005/5a616b5f3a9b4b8b8aaa46411af6bddf.png
[2021061514504599.gif]: /images/20221005/93eec82ca28e467097c5eb440fb93389.png
[20210615150012877.gif]: /images/20221005/e77dc897bc904d61950a440a4c2a329e.png
[20210615150317995.gif]: /images/20221005/8d34fd0052d4451ba93d2829c75388e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 3]: /images/20221005/7668f62c8e0142608039d1ba9b6c1e6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 4]: /images/20221005/cc425170a2724b4881f8b79d292a5124.png
[Java_kotlin_ _join]: https://blog.csdn.net/yuzhiqiang_1993/article/details/117872445
[20210615161311948.gif]: /images/20221005/db89d5fb33c14754a28aa7aa90d320d9.png
[JUC_]: https://yuzhiqiang.blog.csdn.net/article/details/117930548
[Link 1]: https://yuzhiqiang.blog.csdn.net/