线程间的通信 wait、notify

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

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

wait

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

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

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

在这里插入图片描述

再来看看wait源码
在这里插入图片描述

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

在这里插入图片描述

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

  1. public static void main(String[] args) {
  3.         Object o = new Object();
  5.         for (int i = 0; i < 5; i++) {
  7.             new Thread(() -> {
  9.                 synchronized (o) {
  12.                     System.out.println(Thread.currentThread().getName() + "开始执行");
  13.                     try {
  16.                         TimeUnit.SECONDS.sleep(2);
  17. //                        o.wait(2000);
  18.                         System.out.println(Thread.currentThread().getName() + "被唤醒");
  19.                     } catch (InterruptedException e) {
  21.                         e.printStackTrace();
  22.                     }
  24.                     System.out.println(Thread.currentThread().getName() + "执行完毕");
  26.                 }
  27.             }).start();
  29.         }
  31.     }

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

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

  1. public static void main(String[] args) {
  3.         Object o = new Object();
  5.         for (int i = 0; i < 5; i++) {
  7.             new Thread(() -> {
  9.                 synchronized (o) {
  12.                     System.out.println(Thread.currentThread().getName() + "开始执行");
  13.                     try {
  16. //                        TimeUnit.SECONDS.sleep(2);
  17.                         o.wait(2000);
  18.                         System.out.println(Thread.currentThread().getName() + "被唤醒");
  19.                     } catch (InterruptedException e) {
  21.                         e.printStackTrace();
  22.                     }
  24.                     System.out.println(Thread.currentThread().getName() + "执行完毕");
  26.                 }
  27.             }).start();
  29.         }
  31.     }

运行结果如下：
在这里插入图片描述

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

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

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

  1. public static void main(String[] args) {
  3.         Object o = new Object();
  5.         for (int i = 0; i < 5; i++) {
  7.             new Thread(() -> {
  9.                 synchronized (o) {
  12.                     System.out.println(Thread.currentThread().getName() + "开始执行");
  13.                     try {
  15.                         o.wait();
  16.                         System.out.println(Thread.currentThread().getName() + "被唤醒");
  17.                     } catch (InterruptedException e) {
  19.                         e.printStackTrace();
  20.                     }
  22.                     System.out.println(Thread.currentThread().getName() + "执行完毕");
  24.                 }
  25.             }).start();
  27.         }
  29.     }

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

notify

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

  1. public static void main(String[] args) {
  3.         Object o = new Object();
  5.         for (int i = 0; i < 5; i++) {
  7.             new Thread(() -> {
  9.                 synchronized (o) {
  12.                     System.out.println(Thread.currentThread().getName() + "开始执行");
  13.                     try {
  15.                         o.wait();
  16.                         System.out.println(Thread.currentThread().getName() + "被唤醒");
  17.                     } catch (InterruptedException e) {
  19.                         e.printStackTrace();
  20.                     }
  22.                     System.out.println(Thread.currentThread().getName() + "执行完毕");
  24.                 }
  25.             }).start();
  27.         }
  30.         /*让主线程休眠2秒钟*/
  31.         try {
  33.             TimeUnit.SECONDS.sleep(2);
  34.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  39.         synchronized (o) {
  41.             o.notify();
  42.         }
  44.     }

看一下运行结果：

在这里插入图片描述

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

notifyAll

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

来用一把：

  1. public static void main(String[] args) {
  3.         Object o = new Object();
  5.         for (int i = 0; i < 5; i++) {
  7.             new Thread(() -> {
  9.                 synchronized (o) {
  12.                     System.out.println(Thread.currentThread().getName() + "开始执行");
  13.                     try {
  15.                         o.wait();
  16.                         System.out.println(Thread.currentThread().getName() + "被唤醒");
  17.                     } catch (InterruptedException e) {
  19.                         e.printStackTrace();
  20.                     }
  22.                     System.out.println(Thread.currentThread().getName() + "执行完毕");
  24.                 }
  25.             }).start();
  27.         }
  30.         /*让主线程休眠2秒钟*/
  31.         try {
  33.             TimeUnit.SECONDS.sleep(2);
  34.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  39.         synchronized (o) {
  41.             o.notifyAll();
  42.         }
  44.     }

运行结果如下：
在这里插入图片描述

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

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

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

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

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

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

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

  1. /**
  2.  * 模拟请求高德接口
  3.  */
  4. class GaoDeRunnable implements Runnable {
  6.     /*模拟的锁对象*/
  7.     Object lock = null;
  9.     /*接口返回的结果*/
  10.     private String result = "";
  12.     public GaoDeRunnable(Object lock) {
  14.         this.lock = lock;
  15.     }
  17.     public String getResult() {
  19.         return result;
  20.     }
  22.     public void setResult(String result) {
  24.         this.result = result;
  25.     }
  27.     @Override
  28.     public void run() {
  30.         /*模拟请求高德接口*/
  32.         synchronized (lock) {
  34.             System.out.println("高德请求开始执行....");
  35.             try {
  37.                 TimeUnit.SECONDS.sleep(2);
  38.             } catch (InterruptedException e) {
  40.                 e.printStackTrace();
  41.             }
  44.             result = "gaodeResult";
  46.             System.out.println("高德接口请求完毕,唤醒等待的线程");
  48.             /*执行完毕  唤醒等待的线程*/
  49.             lock.notifyAll();
  50.         }
  52.     }
  55. }
  58. /**
  59.  * 模拟请求百度接口
  60.  */
  61. class BaiDuRunnable implements Runnable {
  63.     Object lock = null;
  65.     private String result = "";
  67.     public BaiDuRunnable(Object lock) {
  69.         this.lock = lock;
  70.     }
  72.     public String getResult() {
  74.         return result;
  75.     }
  77.     public void setResult(String result) {
  79.         this.result = result;
  80.     }
  82.     @Override
  83.     public void run() {
  85.         /*模拟请求高德接口*/
  87.         synchronized (lock) {
  89.             System.out.println("百度请求开始执行....");
  90.             try {
  92.                 TimeUnit.SECONDS.sleep(1);
  93.             } catch (InterruptedException e) {
  95.                 e.printStackTrace();
  96.             }
  99.             result = "baiduResult";
  101.             System.out.println("百度接口请求完毕,唤醒等待的线程");
  103.             lock.notifyAll();
  104.         }
  106.     }
  109. }

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

main方法代码如下：

  1. public static void main(String[] args) {
  4.         /*高德 锁*/
  5.         Object gaodeObjLock = new Object();
  6.         /*百度 锁*/
  7.         Object baiduObjLock = new Object();
  9.         /*模拟请求高德接口的Runnable*/
  10.         GaoDeRunnable gaoDeRunnable = new GaoDeRunnable(gaodeObjLock);
  11.         /*模拟请求百度接口的Runnable*/
  12.         BaiDuRunnable baiDuRunnable = new BaiDuRunnable(baiduObjLock);
  14.         /*启动两个线程去执行*/
  15.         new Thread(gaoDeRunnable).start();
  16.         new Thread(baiDuRunnable).start();
  18.         /*等待高德Runnable返回数据*/
  19.         synchronized (gaodeObjLock) {
  21.             while (gaoDeRunnable.getResult().isEmpty()) {
  23.                 try {
  25.                     gaodeObjLock.wait();
  26.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.             }
  31.             /*高德接口执行完毕*/
  32.             System.out.println("高德接口执行完毕，获取的结果是：" + gaoDeRunnable.getResult());
  34.         }
  36.         /*等待百度Runnable返回数据*/
  37.         synchronized (baiduObjLock) {
  39.             while (baiDuRunnable.getResult().isEmpty()) {
  41.                 try {
  43.                     baiduObjLock.wait();
  44.                 } catch (InterruptedException e) {
  46.                     e.printStackTrace();
  47.                 }
  50.             }
  53.             /*高德接口执行完毕*/
  54.             System.out.println("百度接口执行完毕，获取的结果是：" + baiDuRunnable.getResult());
  55.         }
  58.         System.out.println("两个接口都执行完毕了，最终的数据是：" + gaoDeRunnable.getResult() + "-----" + baiDuRunnable.getResult());
  60.     }

下面来看看运行效果：

在这里插入图片描述

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

好了，wait方法就是这些

下一篇：

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

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

发表评论

表情：
评论列表 （有 0 条评论，229人围观）

还没有评论，来说两句吧...

相关阅读

    相关 线程间的通信

    1、什么是多线程之间通信 多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 于是我们引出了等待唤醒机制：

    梦里梦外;梦里梦外;/ 0 赞/ 76 阅读

    相关 线程间通信Object的waitnotify

    wait/notify等待通知方式 等待通知机制就是将处于等待状态的线程将由其它线程发出通知后重新获取CPU资源，继续执行之前没有执行完的任务。最典型的例子生产者–消费者

    Dear 丶Dear 丶/ 0 赞/ 238 阅读

    相关 线程间通信

    为什么需要线程通讯 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这

    心已赠人心已赠人/ 0 赞/ 358 阅读

    相关 线程间的通信

      https://www.cnblogs.com/hapjin/p/5492619.html 通常可用把并行程序理解为一组相互独立的、能够发关和接收消息的组件，这也称为角

    朱雀朱雀/ 0 赞/ 208 阅读

    相关 线程间通信

    线程和线程之间不是独立的个体，它们彼此之间可以互相通信和协作。 线程通信就是在线程之间传递信息，保证他们能够协同工作。在线程间进行通信后，系统之间的交互性会更强大，在大大提高

    Myth丶恋晨Myth丶恋晨/ 0 赞/ 364 阅读

    相关 线程间通信

    注意： 必须在同步方法中使用wait和notify方法，因为执行wait和notify的前提条件是必须持有同步方法（或块）的monitor的所有权，否则将会抛出异常

    女爷i女爷i/ 0 赞/ 488 阅读

    相关 线程间的通信

    典型例子就是生产者-消费者模式，仓库为空时，消费者无法从仓库调动产品，只能wait，直到仓库有产品时被notify；仓库满了时，生产者则暂时停止生产（wait），直到仓库有空被

    喜欢ヅ旅行喜欢ヅ旅行/ 0 赞/ 340 阅读