java干货 线程间通信

文章目录

    • 一、线程间通信
      • [1.1 为什么要处理线程间通信?](#1.1 为什么要处理线程间通信?)
      • [1.2 什么是等待唤醒机制?](#1.2 什么是等待唤醒机制?)
    • 二、等待唤醒机制使用
      • [2.1 等待唤醒机制用到的方法](#2.1 等待唤醒机制用到的方法)
        • [2.1.1 wait](#2.1.1 wait)
        • [2.1.2 notify](#2.1.2 notify)
      • [2.2 线程通信代码实践](#2.2 线程通信代码实践)
        • [2.2.1 重要说明](#2.2.1 重要说明)
        • [2.2.2 代码](#2.2.2 代码)

一、线程间通信

1.1 为什么要处理线程间通信?

  • 在默认情况下,cpu是默认切换线程来执行的,当我们需要多个线程共同来完成一个任务,希望他们按照一定的规律执行,那么就需要他们进行通信协调,以达到我们的目的
  • 其次,对于共享变量的访问,我们通常加上synchronized,存在锁的竞争,我们也可以使用等待唤醒机制,协调线程对变量的访问,保证数据的一致性

1.2 什么是等待唤醒机制?

说到线程,我们常提到线程之间的竞争,如多线程下锁的竞争。好比在公司里你和同事在晋升时的竞争,但是多数情况下,还是你们合作共同完成一些任务。也就是一个线程进行了一定操作后,进入等待状态 (waiting),等待其他线程完成任务后将他唤醒(notify)。还有就是当需要等待多个线程时,可以使用notifyAll(),将等待中的线程全部唤醒

二、等待唤醒机制使用

2.1 等待唤醒机制用到的方法

2.1.1 wait
  • wait() 使当前线程进入等待状态,直到被其他线程使用 notify() 或 notifyAll() 唤醒,无限期等待,直到被唤醒。使用场景: 当线程需要等待某个条件变化时使用,无需考虑超时。

    public final void wait() throws InterruptedException {
    wait(0L);
    }

  • wait(long timeoutMillis),本质上调用的还是这个native 方法

    public final native void wait(long timeoutMillis);

  • wait(long timeoutMillis, int nanos) 可以被其他线程调用 notify() 或 notifyAll() 来唤醒,也可以在超时后自动唤醒。

    public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
    if (timeoutMillis < 0) {
    throw new IllegalArgumentException("timeoutMillis value is negative");
    }

          if (nanos < 0 || nanos > 999999) {
              throw new IllegalArgumentException(
                                  "nanosecond timeout value out of range");
          }
    
          if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
              timeoutMillis++;
          }
    
          wait(timeoutMillis);
      }
    
2.1.2 notify
  • notify 是 Object 类的方法,任何对象都可以调用它。notify 方法用于唤醒一个在该对象的监视器上等待的线程。

  • notify() 适用于只需要唤醒一个等待线程的情况,如果有多个线程等待,随机唤醒一个

    public final native void notify();

  • notifyAll() 唤醒对象监视器上所有等待的线程

    public final native void notifyAll();

2.2 线程通信代码实践

2.2.1 重要说明
  • 等待和通知唤醒必须放在同步代码块
    是为了确保线程在进入等待状态和被唤醒时,对共享资源的访问是受控和一致的。这种机制保证了线程间的协调和通信是安全的,避免了竞争条件和数据不一致的问题。同步块保证了在任意时刻只有一个线程 可以执行同步代码块中的代码,从而确保了线程间通信的正确性和一致性。
    举个例子,张三、李四、王五共同完成一个任务,要求张三先做,再到李四、最后王五,那么三个人就是三个线程,一个人在做任务的时候,其他人是不能动的。张三做完了,把执行权交给李四,并通知李四,李四执行完了,通知王五。
  • 调用wait ,那么当前线程也就释放了锁,即交出执行权,线程进入WAITING 状态
  • wait 和 notify 必须由同一个锁对象 调用。一个锁对象可以唤醒 由同一个锁对象调用wait 后的线程
  • wait 和 notify 是属于 Object 类 的,锁对象可以是任意对象,其他类默认都是继承了Object类的
2.2.2 代码
  • 客人来了,张三洗菜、李四切菜、王五炒菜

    public class Demo10 {
    private static final Object lock = new Object(); // 锁对象
    private static boolean vegetablesWashed = false; // 是否已经洗菜完成
    private static boolean vegetablesCut = false; // 是否已经切菜完成
    public static void main(String[] args) {
    new Thread(new Runnable() {
    @Override
    public void run() {
    synchronized (lock){
    while (!vegetablesCut){
    try {
    System.out.println("王五等待李四切菜...");
    lock.wait(); // 李四没有切完菜,继续等
    } catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    }
    }
    System.out.println("》》》》王五开始炒菜《《《《");
    try {
    Thread.sleep(1200); // 模拟炒菜过程
    System.out.println("》》》王五炒菜完成《《《");
    lock.notifyAll();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    }
    },"王五线程").start();

          new Thread(new Runnable() {
              @Override
              public void run() {
                  synchronized (lock){
                      while (!vegetablesWashed){
                          try {
                              System.out.println("李四等待张三洗菜...");
                              lock.wait(); // 张三没有切完菜,继续等
                          } catch (InterruptedException e) {
                              Thread.currentThread().interrupt();
                          }
                      }
                      System.out.println("======李四开始切菜======");
                      try {
                          Thread.sleep(1600);  // 模拟切菜过程
                          vegetablesCut = true;
                          System.out.println("===李四切完菜了===");
    
                          lock.notifyAll(); // 通知王五炒菜
                      } catch (InterruptedException e) {
                          Thread.currentThread().interrupt();
                      }
                  }
              }
          },"李四线程").start();
    
          new Thread(new Runnable() {
              @Override
              public void run() {
                  synchronized (lock){
                      System.out.println("----张三开始洗菜----");
                      try {
                          Thread.sleep(1500);  // 模拟洗菜过程
    
                          vegetablesWashed = true;
                          System.out.println("---张三洗完菜了---");
                          lock.notifyAll();
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
          },"张三线程").start();
    
      }
    

    }

    王五等待李四切菜...
    李四等待张三洗菜...
    ----张三开始洗菜----
    ---张三洗完菜了---
    王五等待李四切菜...
    ======李四开始切菜======
    ===李四切完菜了===
    》》》》王五开始炒菜《《《《
    》》》王五炒菜完成《《《

分析:上一个人未完成,那么下一个人就继续等待。一个人完成了,要通知所有人,每个人根据自己的顺序,接到通知后,看是否要做,不做任务就继续等待。保证了张三先洗完菜,李四再开始切菜,李四切完菜,王五再炒菜的顺序

相关推荐
IT技术分享社区11 分钟前
C#实战:使用腾讯云识别服务轻松提取火车票信息
开发语言·c#·云计算·腾讯云·共识算法
极客代码14 分钟前
【Python TensorFlow】入门到精通
开发语言·人工智能·python·深度学习·tensorflow
疯一样的码农20 分钟前
Python 正则表达式(RegEx)
开发语言·python·正则表达式
代码之光_198021 分钟前
保障性住房管理:SpringBoot技术优势分析
java·spring boot·后端
ajsbxi27 分钟前
苍穹外卖学习记录
java·笔记·后端·学习·nginx·spring·servlet
&岁月不待人&42 分钟前
Kotlin by lazy和lateinit的使用及区别
android·开发语言·kotlin
StayInLove1 小时前
G1垃圾回收器日志详解
java·开发语言
对许1 小时前
SLF4J: Failed to load class “org.slf4j.impl.StaticLoggerBinder“
java·log4j
无尽的大道1 小时前
Java字符串深度解析:String的实现、常量池与性能优化
java·开发语言·性能优化
爱吃生蚝的于勒1 小时前
深入学习指针(5)!!!!!!!!!!!!!!!
c语言·开发语言·数据结构·学习·计算机网络·算法