12-线程通讯（线程等待和唤醒）

已于 2023-06-13 09:47:11 修改
阅读量488 收藏 1
点赞数 3
分类专栏： 多线程 文章标签： java
于 2023-02-22 21:22:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WWXDwrn/article/details/129159904
版权

目录

1.方法介绍

1.1.wait()/wait(long timeout)：让当前线程进入等待状态。

1.1.1.wait执行流程

1.1.2.wait结束等待的条件

1.1.3.wait() VS wait(long timeout)

1.1.4.为什么wait要放在Object中？

--->PS：wait(0) 和 sleep(0) 的区别

--->PS：wait 和 sleep 释放锁行为的区别

--->PS：（常见面试题）wait 和 sleep 的区别（小结）

--->PS：3种方法让线程进入休眠/等待状态

1.2.notify()：唤醒当前对象上一个休眠的线程（随机）。

1.3.notifyAll()：唤醒当前对象上的所有线程。

2.注意事项：

由于线程之间是抢占式执⾏的，因此线程之间执⾏的先后顺序难以预知。但是实际开发中有时候希望合理地协调多个线程之间的执⾏先后顺序。

球场上的每个运动员都是独⽴的 "执⾏流"，可以认为是⼀个 "线程"。⽽完成⼀个具体的进攻得分动作，则需要多个运动员相互配合， 按照⼀定的顺序执⾏⼀定的动作，线程1 先 "传球"，线程2 才能 "扣篮"。

1.方法介绍

完成这个协调⼯作（线程通讯），主要涉及到以下三个⽅法。注意这三个方法都是对象级别的（需要通过"对象."来调用），【不是锁级别，如Thread.sleep()】都是Object类的内置方法。

1.1.wait()/wait(long timeout)：让当前线程进入等待状态。

1.1.1.wait执行流程

  1. 使当前执⾏代码的线程进⾏等待。(把线程放到等待队列中)。
  2. 释放当前的锁。
  3. 满⾜⼀定条件时被唤醒, 重新尝试获取这个锁。

1.1.2.wait结束等待的条件

  1. 其他线程调⽤该对象的 notify ⽅法。wait/notify 唤醒顺序是无序的。
  2. wait 等待时间超时 (wait ⽅法提供⼀个带有 timeout 参数的版本, 来指定等待时间)。
  3. 其他线程调⽤该等待线程的 interrupted ⽅法, 导致 wait 抛出 InterruptedException 异常。 
/**
 * wait使用
 */
public class WaitDemo {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            System.out.println("线程1开始执行");
            try {
                synchronized (lock) {
                    System.out.println("线程1调用wait方法....");
                    //无限期等待状态
                    lock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1执行完成");
        },"线程1");
        t1.start();
    }
}

import java.util.concurrent.TimeUnit;

public class WaitSleepDemo7 {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock){
                System.out.println("线程1:开始执行");
                try{
                    lock.wait(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1:结束执行");
            }
            System.out.println("线程1:终止执行");
        },"wait0");
        t1.start();

        TimeUnit.SECONDS.sleep(1);
        System.out.println("执行线程1的终止方法");
        t1.interrupt();
    }
}

1.1.3.wait() VS wait(long timeout)

1-不同点：wait(long timeout)：当线程超过了设置的时间之后，自动恢复执行；而wait()：无限等待状态。（0表示无限等待状态）

2-不同点：wait(long timeout)：线程会进入TIMED_WAITING状态；而wait()：线程会进入WAITING状态。

import java.time.LocalDateTime;

public class WaitDemo4 {
    public static void main(String[] args) {
        Object lock = new Object();
        Object lock2 = new Object();

        new Thread(() -> {
            System.out.println("线程1:开始执行");
            synchronized (lock){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1:执行完成");
            }
        },"无参wait线程").start();

        new Thread(() -> {
            synchronized (lock2){
                System.out.println("线程2:开始执行 |" + LocalDateTime.now());
                try {
                    lock2.wait(60 * 60 * 60 * 1000); //1h
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2:执行完成 |" + LocalDateTime.now());
            }
        },"有参wait线程").start();
    }
}

 

3-共同点：无论是wait(long timeout)还是wait()，都会使当前线程进入休眠状态。

4-共同点：无论是wait(long timeout)还是wait()，都能使用notify/notifyAll进行唤醒。

import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;

public class WaitDemo6 {
    public static void main(String[] args) {
        Object lock = new Object();

        new Thread(() -> {
            System.out.println("线程1:开始执行");
            synchronized (lock){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1:执行完成");
            }
        },"无参wait线程").start();

        new Thread(() -> {
            synchronized (lock){
                System.out.println("线程2:开始执行 |" + LocalDateTime.now());
                try {
                    lock.wait(60 * 60 * 60 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2:执行完成 |" + LocalDateTime.now());
            }
        },"有参wait线程").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock){
               System.out.println("唤醒所有线程");
               lock.notifyAll();
           }
        }).start();
    }
}

1.1.4.为什么wait要放在Object中？

wait 使用要加锁，也就是要操作锁，锁是针对对象级别的而非线程级别的，线程和对象是⼀对多，所以 wait 最便利的方式是放在 Object 中。

wait(num)和sleep(num)：当num>0时，二者执行效果一样。

--->PS：wait(0) 和 sleep(0) 的区别

  1. wait(0) 表示无期限地等待，直到有线程唤醒它为止。
  2. Thread.sleep(0) 调用后会让出CPU执行权，让线程稍做休眠，然后重新调度，重新触发一次 CPU 竞争，不管是否竞争到CPU执行权，都会继续执行，直到执行结束。（类似于Thread.yield()）
/**
 * wait(0)和sleep(0)
 */
public class WaitSleepDemo7 {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock){
                System.out.println("线程1:开始执行");
                try{
                    lock.wait(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1:执行结束");
            }
        },"wait(0)");
        t1.start();

        Thread t2 = new Thread(() -> {
            System.out.println("线程2:开始执行");
            try {
                Thread.sleep(0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2:执行结束");
        },"sleep(0)");
        t2.start();
    }
}

--->PS：wait 和 sleep 释放锁行为的区别

wait和sleep在有锁的情况下，锁的处理行为是完全不同的：

  1. wait方法（不管是有参还是无参）在执行时都会释放锁。
  2. sleep方法不会释放锁。
import java.util.concurrent.TimeUnit;

/**
 * wait和sleep释放锁行为的区别
 */
public class WaitSleepDemo8 {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock){
                System.out.println("线程1:开始执行");
                try{
                    lock.wait(3 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1:结束执行");
            }
        },"wait");
        t1.start();

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("线程2:开始执行");
                try {
                    Thread.sleep(3 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2:结束执行");
            }
        },"sleep");
        t2.start();

        //创建2个线程，先让线程休眠1秒之后，尝试获取锁，看能不能获取到锁
        //如果可以获取到锁，说明休眠时线程是释放锁的，而如果获取不到锁，说明是不释放锁的
        Thread t3 = new Thread(() -> {
            try{
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("尝试获取wait方法的锁");
            synchronized (lock){
                System.out.println("成功获取wait的锁");
            }
        },"wait2");
        t3.start();

        Thread t4 = new Thread(() -> {
            try{
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("尝试获取sleep方法的锁");
            synchronized (lock2){
                System.out.println("成功获取sleep的锁");
            }
        },"sleep2");
        t4.start();
    }
}

为什么wait释放锁而sleep不释放锁？

JVM 强制语法检查，wait 方法默认等待无期限。

--->PS：（常见面试题）wait 和 sleep 的区别（小结）

二者的相同点：

  1. 都可以让线程休眠。
  2. 都可以响应 interrupt 中断的请求。
  3. wait(num) 和 sleep(num)：当num>0时，二者执行效果一样。

二者的不同点：

  1. wait 必须在 synchronized 中使用；而 sleep 却不用。
  2. wait 是 Object 的方法（属于对象级别）；而sleep 是 Thread 的方法（属于线程级别）。
  3. wait 释放锁；而sleep 不释放锁。
  4. wait 有可能无限期地等待下去；而sleep 有明确的终止等待时间。 即：wait 可传参，也可不传参；而 sleep必须要传递一个数值类型的参数，否则会报错。
  5. wait 和 sleep 产生的线程状态是不同的：无参的 wait 是 WAITING 状态；而sleep 是 TIMED_WAITING 状态。
  6. 一般情况下（响应 interrupt 除过），wait 可以接收一个 notify/notifyAll 之后就继续执行；而 sleep 只能等待超过时间之后再恢复执行。
  7. wait(0) 表示无期限地等待；而sleep(0)表示重新触发一次 CPU 竞争。

--->PS：3种方法让线程进入休眠/等待状态

  1. sleep（传参设置休眠时间；不可唤醒）
  2. TimeUnit（传参设置休眠时间；不可唤醒）
  3. wait（可传参设置休眠时间，也可不传参无限等待；可以唤醒）

1.2.notify()：唤醒当前对象上一个休眠的线程（随机）。

  • ⽅法notify()也要在同步⽅法或同步块中调⽤，该⽅法是⽤来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。

  • 如果有多个线程等待，则由线程调度器随机挑选出⼀个呈 wait 状态的线程。(并没有 "先来后到") （官方是随机的，但具体实现针对不同的JVM是不一样的）

/**
 * notify使用
 */
public class WaitDemo2 {
    public static void main(String[] args) {
        Object lock = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            System.out.println("线程1开始执行");
            try {
                synchronized (lock) {
                    System.out.println("线程1调用wait方法....");
                    //无限期的等待状态
                    lock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1执行完成");
        },"线程1");

        Thread t2 = new Thread(() -> {
            System.out.println("线程2开始执行");
            try {
                synchronized (lock) {
                    System.out.println("线程2调用wait方法....");
                    //无限期的等待状态
                    lock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2执行完成");
        },"线程2");

        Thread t3 = new Thread(() -> {
            System.out.println("线程3开始执行");
            try {
                synchronized (lock2) {
                    System.out.println("线程3调用wait方法....");
                    //无限期的等待状态
                    lock2.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程3执行完成");
        },"线程3");

        t1.start();
        t2.start();
        t3.start();

        //唤醒lock对象上休眠的线程（随机唤醒一个）
        Thread t4 = new Thread(() -> {
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println("线程4：开始执行，唤醒线程");
            synchronized (lock) {
                //发出唤醒通知
                lock.notify();
                System.out.println("线程4：执行了唤醒操作");
                try{
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println("线程4：synchronized执行完了");
            }
        }, "线程4");
        t4.start();
    }
}

1.3.notifyAll()：唤醒当前对象上的所有线程。

/**
 * notifyAll使用
 */
public class WaitDemo3 {
    public static void main(String[] args) {
        Object lock = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            System.out.println("线程1开始执行");
            try {
                synchronized (lock) {
                    System.out.println("线程1调用wait方法....");
                    //无限期的等待状态
                    lock.wait();
                    System.out.println("线程1:恢复执行之后又进入休眠状态");
                    Thread.sleep(2000);
                    System.out.println("线程1执行完成");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程1");

        Thread t2 = new Thread(() -> {
            System.out.println("线程2开始执行");
            try {
                synchronized (lock2) {
                    System.out.println("线程2调用wait方法....");
                    //无限期的等待状态
                    lock2.wait();
                    System.out.println("线程2:恢复执行之后又进入休眠状态");
                    Thread.sleep(2000);
                    System.out.println("线程2执行完成");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程2");

        Thread t3 = new Thread(() -> {
            System.out.println("线程3开始执行");
            try {
                synchronized (lock) {
                    System.out.println("线程3调用wait方法....");
                    //无限期的等待状态
                    lock.wait();
                    System.out.println("线程3:恢复执行之后又进入休眠状态");
                    Thread.sleep(2000);
                    System.out.println("线程3执行完成");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程3");

        t1.start();
        t2.start();
        t3.start();

        //唤醒lock对象上休眠的线程（随机唤醒一个）
        Thread t4 = new Thread(() -> {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
            System.out.println("线程4:开始执行，唤醒线程");
            synchronized (lock){
                //发出唤醒通知
                lock.notifyAll();
                System.out.println("线程4:执行了唤醒操作");
                try{
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println("线程4:synchronized执行完了");
            }
        }, "线程4");
        t4.start();
    }
}

2.注意事项：

①wait/notify/notifyAll必须要配合synchronized一起使用，否则会报错（JVM的强制规定，之所以这样规定，是为了解决线程通讯时执行混乱的问题，synchronized起到约束限制的作用）。

②wait/notify/notifyAll进行synchronized加锁，一定要使用同一个对象进行加锁。

③当调用了notify/notifyAll之后，当前线程不会⻢上释放该对象锁，要等到执⾏notify/notifyAll⽅法的线程将程序执⾏完，也就是退出同步代码块（synchronized）之后才会释放对象锁。【程序也并不会立即恢复执行，而是尝试获取锁，只有得到锁之后才能继续执行。】

④notify/notifyAll可以多次调用，也可以在wait之前调用(是无用功)。

⑤notifyAll 并不是唤醒所有 wait 等待的线程，而是唤醒当前对象处于 wait 等待的所有线程。

X-musk
关注
专栏目录
java 多线程通信用什么流_Java多线程-线程通信
weixin_42400669的博客
02-24 1503
通信的方式要想实现多个线程之间的协同，如：线程执行先后顺序、获取某个线程执行的结果等等。涉及到线程之间的相互通信，分为下面四类：文件共享网络共享共享变量JDK提供的线程协调APIsuspend/resume、wait/notify、park/unpark文件共享public class MainTest {public static void main(String[] args) {// 线程1...
线程等待与唤醒
一名在校大三学习JAVA
06-28 1963
目录概念等待方法 唤醒方法 唤醒和阻塞具体的使用 wait和sleep的区别
线程的等待与唤醒
木易三水良
06-17 362
1、Object的wait()与notify() public class Test { private static Object lock = new Object(); public static void main(String[] args) { new Thread(() -> { System.out.println(Thread.currentThread().getName() + "开始执行"); sy
让线程等待唤醒的3种方法及各自存在的问题
最新发布
fuyuan98520的博客
07-15 278
线程先要获得并持有锁，必须在锁块(synchronized或lock)中，必须要先等待后唤醒，线程才能够被唤醒。综上所述：wait和notify方法必须要在同步块或者方法里面，且成对出现，必须先wait后notify。结论：要使用必须包在synchronized 锁之间，必须先持有锁。结论二：将notify放在wait方法前面程序无法执行，无法唤醒。结论：必须使用lock()和unlock()结论： 许可的累加上限是1。
线程状态之等待与唤醒
qq_41596080的博客
07-25 110
public static void main(String[] args) { //创建锁对象保证唯一 Object object = new Object(); //创建一个消费者 new Thread(){ @Override public void run() { //一直等着卖包子 while (true){ ...
线程的等待与唤醒机制
ccc的博客
05-09 3971
为了更高效的处理一些时间片短，任务量大的任务，我们可能会经常用到多线程。但是多线程的环境下，很容易出现线程并发问题，线程死锁就是很常见的一种并发问题。为了避免此类问题，我们会用到线程间的通信，而等待唤醒机制，就是线程间通信的一种形式。 等待唤醒机制用到的方法主要有： public final void wait() throws InterruptedException ： 当前线程必
xiancheng.zip_线程间通讯
09-23
下面我们将围绕标题“线程间通讯”和描述“通过代码实现线程间通讯，实现等待、唤醒等机制”来深入讲解相关知识点。 1. **线程的基本概念**： - **线程**是操作系统分配处理器时间的基本单位，一个进程中可以有多...
Java并发编程线程间通讯实现过程详解
08-19
CyclicBarrier是Java提供的一种同步机制，它允许一组线程等待直到所有线程都达到某个状态。CyclicBarrier可以用于实现线程间的同步通信。 CountDownLatch CountDownLatch是Java提供的一种同步机制，它允许一个或多...
Java多线程通讯之wait,notify的区别详解
08-27
Java多线程通讯是指在多线程编程中，线程之间如何进行通讯和同步的问题。其中，wait和notify是两个非常重要的方法，用于控制线程的状态和同步。 wait方法： wait方法是Object类中的方法，用于使当前线程等待某个...
IOT-OS之RT-Thread（五）--- 线程调度器与线程对象管理
流云
09-21 2370
之前的博客UCOS任务调度器与UCOS任务间通信介绍了多任务并行机制、任务调度原理、任务间同步、任务间通信等的实现原理，本文主要从RT-Thread与UCOS的对比与差异看RT-Thread线程管理与线程间同步/通信的实现。 一、线程对象管理 RT-Thread 线程管理的主要功能是对线程进行管理和调度，系统中总共存在两类线程，分别是系统线程和用户线程，系统线程是由 RT-Thread 内核创建的...
第二部分 线程的等待和唤醒
热门推荐
小崔的博客
01-13 1万+
<br /><br /><br /><br /><br />从这个图中可以看出，等待状态是一种特殊的状态。使线程陷入等待实际上是暂时剥夺线程当前拥有的CPU时间片和获取CPU时间片的资格，使其返回到就绪状态。除非被唤醒，否则等待时间已满，该线程将一直等待。不会被JVM线程调度器选中并赋予CPU时间片。处于等待的线程一旦恢复执行，与其他处于就绪状态被线程调度器选中的线程不同，将从上次结束执行的断点处开始执行，而非从头开始。<br /> 使线程中断运行，返回就绪状态的手段是调用java.lang.Object对
线程等待和唤醒的方法(一)
liuyichao8888的博客
11-16 452
学习synchronized可重入锁在以下三种情况的不同表现。 1、正常wait()和notify情况 /** * 使用Object类中得wait()方法让线程等待，使用Object类中得notify()方法唤醒线程 */ public class WaitNotifyLock { public static void main(String[] args) { Object object = new Object(); new Thread(()
线程(Thread)的三种等待唤醒机制详解
全栈行动派的博客
04-10 3750
线程的等待唤醒机制是一种经典的“生产者和消费者”模型。目前可以通过三种方式实现各有优缺点，本篇文章通过实例代码演示三种实现方式以及优缺点。
3.线程等待与唤醒
My classmates
10-26 721
我们在之前的讲解了如何自己实现临界区以及什么是Windows自旋锁,这两种同步方案在线程无法进入临界区时都会让当前线程进入等待状态,一种是通过Sleep函数实现的,一种是通过让当前的CPU&amp;amp;amp;quot;空转”实现的,但这两种等待方式都有局限性: 通过Sleep函数进行等待,等待时间该如何确定呢? 通过“空转”的方式进行等待,只有等待时间很短的情况下才有意义,否则对CPU资源是种浪费。而且自旋锁只能在多核的环...
Java线程的等待与唤醒
持续学习，共同进步
12-23 771
生产者和消费者必须使用同步代码块包裹起来，保证等待和唤醒只能有一个执行，同步使用的锁对象必须保证唯一 Thread中重要方法 void wait() 在其他线程调用此对象的notify（）方法或notifyall（）方法前，导致当前线程等待 void notify() 唤醒在此对象监视器上等待的单个线程后，会继续执行wait方法之后的代码 void notifyAll() 唤醒...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值