搜索

Java 线程通信之 wait/notify 机制

源码共读

共 7215字，需浏览 15分钟

 ·

2021-04-13 21:44

👇👇关注后回复 “进群” ，拉你进程序员交流群👇👇

作者丨ytao

来源丨ytao

前言

Java 线程通信是将多个独立的线程个体进行关联处理，使得线程与线程之间能进行相互通信。比如线程 A 修改了对象的值，然后通知给线程 B，使线程 B 能够知道线程 A 修改的值，这就是线程通信。

wait/notify 机制

一个线程调用 Object 的 wait() 方法，使其线程被阻塞；另一线程调用 Object 的 notify()/notifyAll() 方法，wait() 阻塞的线程继续执行。

wai/notify 方法

方法说明
wait()当前线程被阻塞，线程进入 WAITING 状态
wait(long)设置线程阻塞时长，线程会进入 TIMED_WAITING 状态。如果设置时间内（毫秒）没有通知，则超时返回
wait(long, int)纳秒级别的线程阻塞时长设置
notify()通知同一个对象上已执行 wait() 方法且获得对象锁的等待线程
notifyAll()通知同一对象上所有等待的线程

实现 wait/notify 机制的条件：

  • 调用 wait 线程和 notify 线程必须拥有相同对象锁。

  • wait() 方法和 notify()/notifyAll() 方法必须在 Synchronized 方法或代码块中。

由于 wait/notify 方法是定义在 java.lang.Object中，所以在任何 Java 对象上都可以使用。

wait 方法

在执行 wait() 方法前，当前线程必须已获得对象锁。调用它时会阻塞当前线程，进入等待状态，在当前 wait() 处暂停线程。同时，wait() 方法执行后，会立即释放获得的对象锁。

下面通过案例来查看 wait() 释放锁。

首先查看不使用 wait() 方法时的代码执行情况：

  1. package top.ytao.demo.thread.waitnotify;

  3. /**
  4.  * Created by YangTao
  5.  */
  6. publicclassWaitTest{

  8. staticObject object = newObject();

  10. publicstaticvoid main(String[] args) {

  12. newThread(() -> {
  13. synchronized(object){
  14. System.out.println("开始线程 A");
  15. try{
  16. Thread.sleep(2000L);
  17. } catch(InterruptedException e) {
  18.                     e.printStackTrace();
  19. }
  20. System.out.println("结束线程 A");
  21. }
  22. }, "线程 A").start();


  25. newThread(() -> {
  26. try{
  27. Thread.sleep(500L);
  28. } catch(InterruptedException e) {
  29.                 e.printStackTrace();
  30. }
  31. synchronized(object){
  32. System.out.println("开始线程 B");

  34. System.out.println("结束线程 B");
  35. }
  36. }, "线程 B").start();

  38. }

  40. }

创建 A、B 两个线程，。首先在 B 线程创建后 sleep ，保证 B 线程的打印后于 A 线程执行。在 A 线程中，获取到对象锁后，sleep 一段时间，且时间大于 B 线程的 sleep 时间。

执行结果为：

从上图结果中，可以看到，B 线程一定等 A 线程执行完 synchronize 代码块释放对象锁后 A 线程再获取对象锁进入 synchronize 代码块中。在这过程中，Thread.sleep() 方法也不会释放锁。

当前在 A 线程 synchronize 代码块中执行 wait() 方法后，就会主动释放对象锁，A 线程代码如下：

  1. newThread(() -> {
  2. synchronized(object){
  3. System.out.println("开始线程 A");
  4. try{
  5. // 调用 object 对象的 wait 方法
  6.             object.wait();
  7. Thread.sleep(2000L);
  8. } catch(InterruptedException e) {
  9.             e.printStackTrace();
  10. }
  11. System.out.println("结束线程 A");
  12. }
  13. }, "线程 A").start();

执行结果（这里结果图片放错，查看原文有正确图片）：

同时 A 线程一直处于阻塞状态，不会打印 结束线程A。

wait(long) 方法是设置超时时间，当等待时间大于设置的超时时间后，会继续往 wait(long) 方法后的代码执行。

  1. newThread(() -> {
  2. synchronized(object){
  3. System.out.println("开始线程 A");
  4. try{
  5.             object.wait(1000);
  6. Thread.sleep(2000L);
  7. } catch(InterruptedException e) {
  8.             e.printStackTrace();
  9. }
  10. System.out.println("结束线程 A");
  11. }
  12. }, "线程 A").start();

执行结果

同理，wait(long, int) 方法与 wait(long) 同样，只是多个纳秒级别的时间设置。

notify 方法

同样，在执行 notify() 方法前，当前线程也必须已获得线程锁。调用 notify() 方法后，会通知一个执行了 wait() 方法的阻塞等待线程，使该等待线程重新获取到对象锁，然后继续执行 wait() 后面的代码。但是，与 wait() 方法不同，执行 notify() 后，不会立即释放对象锁，而需要执行完 synchronize 的代码块或方法才会释放锁，所以接收通知的线程也不会立即获得锁，也需要等待执行 notify() 方法的线程释放锁后再获取锁。

notify()

下面是 notify() 方法的使用，实现一个完整的 wait/notify 的例子，同时验证发出通知后，执行 notify() 方法的线程是否立即释放锁，执行 wait() 方法的线程是否立即获取锁。

  1. package top.ytao.demo.thread.waitnotify;

  3. /**
  4.  * Created by YangTao
  5.  */
  6. publicclassWaitNotifyTest{

  8. staticObject object = newObject();

  10. publicstaticvoid main(String[] args) {
  11. System.out.println();

  13. newThread(() -> {
  14. synchronized(object){
  15. System.out.println("开始线程 A");
  16. try{
  17.                     object.wait();
  18. System.out.println("A 线程重新获取到锁，继续进行");
  19. } catch(InterruptedException e) {
  20.                     e.printStackTrace();
  21. }
  22. System.out.println("结束线程 A");
  23. }
  24. }, "线程 A").start();


  27. newThread(() -> {
  28. try{
  29. Thread.sleep(500L);
  30. } catch(InterruptedException e) {
  31.                 e.printStackTrace();
  32. }
  33. synchronized(object){
  34. System.out.println("开始线程 B");
  35.                 object.notify();
  36. System.out.println("线程 B 通知完线程 A");
  37. try{
  38. // 试验执行完 notify() 方法后，A 线程是否能立即获取到锁
  39. Thread.sleep(2000L);
  40. } catch(InterruptedException e) {
  41.                     e.printStackTrace();
  42. }
  43. System.out.println("结束线程 B");
  44. }
  45. }, "线程 B").start();

  47. }

  49. }

以上 A 线程执行 wait() 方法，B 线程执行 notify() 方法，执行结果为：

执行结果中可以看到，B 线程执行 notify() 方法后，即使 sleep 了，A 线程也没有获取到锁，可知，notify() 方法并没有释放锁。

notify() 是通知到等待中的线程，但是调用一次 notify() 方法，只能通知到一个执行 wait() 方法的等待线程。如果有多个等待状态的线程，则需多次调用 notify() 方法，通知到线程顺序则根据执行 wait() 方法的先后顺序进行通知。

下面创建有两个执行 wait() 方法的线程的代码：

  1. package top.ytao.demo.thread.waitnotify;

  3. /**
  4.  * Created by YangTao
  5.  */
  6. publicclassMultiWaitNotifyTest{

  8. staticObject object = newObject();

  10. publicstaticvoid main(String[] args) {
  11. System.out.println();

  13. newThread(() -> {
  14. synchronized(object){
  15. System.out.println("开始线程 A");
  16. try{
  17.                     object.wait();
  18. } catch(InterruptedException e) {
  19.                     e.printStackTrace();
  20. }
  21. System.out.println("结束线程 A");
  22. }
  23. }, "线程 A").start();


  26. newThread(() -> {
  27. try{
  28. Thread.sleep(500L);
  29. } catch(InterruptedException e) {
  30.                 e.printStackTrace();
  31. }
  32. synchronized(object){
  33. System.out.println("开始线程 B");
  34. try{
  35.                     object.wait();
  36. } catch(InterruptedException e) {
  37.                     e.printStackTrace();
  38. }
  39. System.out.println("结束线程 B");
  40. }
  41. }, "线程 B").start();


  44. newThread(() -> {
  45. try{
  46. Thread.sleep(3000L);
  47. } catch(InterruptedException e) {
  48.                 e.printStackTrace();
  49. }
  50. synchronized(object){
  51. System.out.println("开始通知线程 C");
  52.                 object.notify();
  53.                 object.notify();
  54. System.out.println("结束通知线程 C");
  55. }
  56. }, "线程 C").start();

  58. }

  60. }

先 A 线程执行 wait() 方法，然后 B 线程执行 wait() 方法，最后 C 线程调用两次 notify() 方法，执行结果：

notifyAll()

通知多个等待状态的线程，通过多次调用 notify() 方法实现的方案，在实际应用过程中，实现过程不太友好，如果是想通知所有等待状态的线程，可使用 notifyAll() 方法，就能唤醒所有线程。

实现方式，只需将上面 C 线程的多次调用 notify() 方法部分改为调用一次 notifyAll() 方法即可。

  1. newThread(() -> {
  2. try{
  3. Thread.sleep(3000L);
  4. } catch(InterruptedException e) {
  5.         e.printStackTrace();
  6. }
  7. synchronized(object){
  8. System.out.println("开始通知线程 C");
  9.         object.notifyAll();
  10. System.out.println("结束通知线程 C");
  11. }
  12. }, "线程 C").start();

执行结果：

根据不同 JVM 的实现，notifyAll() 的唤醒顺序会有所不同，当前测试环境中，以倒序顺序唤醒线程。

实现生产者消费者模式

生产消费者模式就是一个线程生产数据进行存储，另一线程进行数据提取消费。下面就以两个线程来模拟，生产者生成一个 UUID 存放到 List 对象中，消费者读取 List 对象中的数据，读取完成后进行清除。

实现代码如下：

  1. package top.ytao.demo.thread.waitnotify;

  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.UUID;

  7. /**
  8.  * Created by YangTao
  9.  */
  10. publicclassWaitNotifyModelTest{

  12. // 存储生产者产生的数据
  13. staticList<String> list = newArrayList<>();

  15. publicstaticvoid main(String[] args) {

  17. newThread(() -> {
  18. while(true){
  19. synchronized(list){
  20. // 判断 list 中是否有数据，如果有数据的话，就进入等待状态，等数据消费完
  21. if(list.size() != 0){
  22. try{
  23.                             list.wait();
  24. } catch(InterruptedException e) {
  25.                             e.printStackTrace();
  26. }
  27. }

  29. // list 中没有数据时，产生数据添加到 list 中
  30.                     list.add(UUID.randomUUID().toString());
  31.                     list.notify();
  32. System.out.println(Thread.currentThread().getName() + list);
  33. }
  34. }
  35. }, "生产者线程 A ").start();


  38. newThread(() -> {
  39. while(true){
  40. synchronized(list){
  41. // 如果 list 中没有数据，则进入等待状态，等收到有数据通知后再继续运行
  42. if(list.size() == 0){
  43. try{
  44.                             list.wait();
  45. } catch(InterruptedException e) {
  46.                             e.printStackTrace();
  47. }
  48. }

  50. // 有数据时，读取数据
  51. System.out.println(Thread.currentThread().getName() + list);
  52.                     list.notify();
  53. // 读取完毕，将当前这条 UUID 数据进行清除
  54.                     list.clear();
  55. }
  56. }
  57. }, "消费者线程 B ").start();

  59. }

  61. }

运行结果：

生产者线程运行时，如果已存在未消费的数据，则当前线程进入等待状态，收到通知后，表明数据已消费完，再继续向 list 中添加数据。

消费者线程运行时，如果不存在未消费的数据，则当前线程进入等待状态，收到通知后，表明 List 中已有新数据被添加，继续执行代码消费数据并清除。

不管是生产者还是消费者，基于对象锁，一次只能一个线程能获取到，如果生产者获取到锁就校验是否需要生成数据，如果消费者获取到锁就校验是否有数据可消费。

一个简单的生产者消费者模式就以完成。

总结

等待/通知机制是实现 Java 线程间通信的一种方式，将多线程中，各个独立运行的线程通过相互通信来更高效的协作完成工作，更大效率利用 CPU 处理程序。这也是学习或研究 Java 线程的必学知识点。

-End-

最近有一些小伙伴，让我帮忙找一些 面试题 资料，于是我翻遍了收藏的 5T 资料后，汇总整理出来，可以说是程序员面试必备！所有资料都整理到网盘了，欢迎下载！

点击👆卡片，关注后回复【面试题】即可获取

在看点这里好文分享给更多人↓↓

浏览 15
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
Java多线程中的wait/notify通信模式
java1234
0
Java多线程学习之wait、notify/notifyAll 详解
Java技术精选
0
JAVA之线程池详解
SegmentFault
0
Java多线程之COW机制
ProjectDaedalus
0
Java线程池之ThreadPoolExecutor
ProjectDaedalus
0
wait 和 notify 有坑。。
Java技术栈
0
图解 Java多线程中的 wait() 和 notify() 方法
Java专栏
0
wait 和 notify 有坑。。
全栈架构社区
0
Java专栏：为什么wait和notify必须放在synchronized中？
Java学习之道
0
Java同步之volatile机制详解
愿天堂没有BUG
0
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报