线程的wait，Notification，Interruptions，Sleep，Yield详解

最新推荐文章于 2022-04-22 17:04:18 发布
最新推荐文章于 2022-04-22 17:04:18 发布
阅读量179 收藏
点赞数
分类专栏： java多线程 java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_royi/article/details/82754294
版权

线程的详解

Wait等待

作用：释放锁，使线程进入等待队列中
注意点：

  1. 线程没有持有对象的锁，那么会抛出 IllegalMonitorStateException 异常（既wait方法要在锁方法中执行）
  2. 如果线程 t 被中断，此时中断状态为 true，则 wait 方法将抛出 InterruptedException异常，并将中断状态设置为 false。
  3. 只有通过Notification或设置wait时间才能使线程回到等待队列而不发送异常。
// wait方法是这么用的：
synchronized(m) {
    while(!canExit) {
      m.wait(10); // 等待10ms; 当然中断也是常用的
      canExit = something();  // 判断是否可以退出循环
    }
}
// 2 个知识点：
// 1. 必须先获取到对象上的监视器锁
// 2. wait 有可能被假唤醒

Notification 唤醒

作用：将线程从等待队列中移除
注意点：

  1. 线程 t没有获取到对象上的锁，抛出 IllegalMonitorStateException 异常
  2. 对于哪个线程会被选中而被移出，虚拟机没有提供任何保证，从等待集合中将线程 u 移出，可以让线程 u 得以恢复。注意，恢复之后的线程 u 如果对 m 进行加锁操作将不会成功，直到线程 t 完全释放锁之后。

Interruptions中断

作用：将线程的中断状态设置为 true，并进入销毁
注意点：

  1. 一个小细节：u 被中断，wait 方法返回，并不会立即抛出 InterruptedException 异常，而是在重新获取监视器锁之后才会抛出异常。

测试用例

1.wait 和 notify测试

/**
 * @Auther: cpb
 * @Date: 2018/7/19 16:12
 * @Description:
 */
public class WaitNotify1 {


    public static void main(String[] args) {

        final Object object = new Object();

        new Thread(new Runnable() {

            public void run() {

                synchronized (object) {
                    System.out.println("线程1 获取到监视器锁");
                    try {
                        object.wait();
                        System.out.println("线程1 恢复啦。我为什么这么久才恢复，因为notify方法虽然早就发生了，可是我还要获取锁才能继续执行。");
                    } catch (InterruptedException e) {
                        System.out.println("线程1 wait方法抛出了InterruptedException异常");
                    }
                }
            }
        }, "线程1").start();

        new Thread(new Runnable() {

            public void run() {
                synchronized (object) {
                    System.out.println("线程2 拿到了监视器锁。为什么呢，因为线程1 在 wait 方法的时候会自动释放锁");
                    System.out.println("线程2 执行 notify 操作");
                    object.notify();
                    System.out.println("线程2 执行完了 notify，先休息3秒再说。");
                    try {
                        Thread.sleep(3000);
                        System.out.println("线程2 休息完啦。注意了，调sleep方法和wait方法不一样，不会释放监视器锁");
                    } catch (InterruptedException e) {

                    }
                    System.out.println("线程2 休息够了，结束操作");
                }
            }
        }, "线程2").start();
    }


}

测试结果

线程1 获取到监视器锁
线程2 拿到了监视器锁。为什么呢，因为线程1 在 wait 方法的时候会自动释放锁
线程2 执行 notify 操作
线程2 执行完了 notify，先休息3秒再说。
线程2 休息完啦。注意了，调sleep方法和wait方法不一样，不会释放监视器锁
线程2 休息够了，结束操作
线程1 恢复啦。我为什么这么久才恢复，因为notify方法虽然早就发生了，可是我还要获取锁才能继续执行。

2.wait和interrupt测试

/**
 * @Auther: cpb
 * @Date: 2018/7/19 16:16
 * @Description:
 */
public class WaitNotify2 {


        public static void main(String[] args) {

            final Object object = new Object();

            final Thread thread1 = new Thread(new Runnable() {

                public void run() {

                    synchronized (object) {
                        System.out.println("线程1 获取到监视器锁");
                        try {
                            object.wait();
                            System.out.println("线程1 恢复啦。我为什么这么久才恢复，因为notify方法虽然早就发生了，可是我还要获取锁才能继续执行。");
                        } catch (InterruptedException e) {
                            System.out.println("线程1 wait方法抛出了InterruptedException异常，即使是异常，我也是要获取到监视器锁了才会抛出");
                        }
                    }
                }
            }, "线程1");
            thread1.start();

            new Thread(new Runnable() {

                public void run() {
                    synchronized (object) {
                        System.out.println("线程2 拿到了监视器锁。为什么呢，因为线程1 在 wait 方法的时候会自动释放锁");
                        System.out.println("线程2 设置线程1 中断");
                        thread1.interrupt();
                        System.out.println("线程2 执行完了 中断interrupt，先休息3秒再说。");
                        try {
                            Thread.sleep(3000);
                            System.out.println("线程2 休息完啦。注意了，调sleep方法和wait方法不一样，不会释放监视器锁");
                        } catch (InterruptedException e) {

                        }
                        System.out.println("线程2 休息够了，结束操作");
                    }
                }
            }, "线程2").start();
        }
    }

测试结果

线程1 获取到监视器锁
线程2 拿到了监视器锁。为什么呢，因为线程1 在 wait 方法的时候会自动释放锁
线程2 设置线程1 中断
线程2 执行完了 中断interrupt，先休息3秒再说。
线程2 休息完啦。注意了，调sleep方法和wait方法不一样，不会释放监视器锁
线程2 休息够了，结束操作
线程1 wait方法抛出了InterruptedException异常，即使是异常，我也是要获取到监视器锁了才会抛出

3. wait和interrupt和notify测试

/**
 * @Auther: cpb
 * @Date: 2018/7/19 16:20
 * @Description:
 */
public class WaitNotify3 {

    volatile int a = 0;

    public static void main(String[] args) {

       final Object object = new Object();

        final WaitNotify3 waitNotify = new WaitNotify3();

        final Thread thread1 = new Thread(new Runnable() {

            public void run() {

                synchronized (object) {
                    System.out.println("线程1 获取到监视器锁");
                    try {
                        object.wait();
                        System.out.println("线程1 正常恢复啦。");
                    } catch (InterruptedException e) {
                        System.out.println("线程1 wait方法抛出了InterruptedException异常");
                    }
                }
            }
        }, "线程1");
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {

            public void run() {

                synchronized (object) {
                    System.out.println("线程2 获取到监视器锁");
                    try {
                        object.wait();
                        System.out.println("线程2 正常恢复啦。");
                    } catch (InterruptedException e) {
                        System.out.println("线程2 wait方法抛出了InterruptedException异常");
                    }
                }
            }
        }, "线程2");
        thread2.start();

        // 这里让 thread1 和 thread2 先起来，然后再起后面的 thread3
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

        new Thread(new Runnable() {
            public void run() {
                synchronized (object) {
                    System.out.println("线程3 拿到了监视器锁。");
                    System.out.println("线程3 设置线程1中断");
                    thread1.interrupt(); // 1
                    waitNotify.a = 1; // 这行是为了禁止上下的两行中断和notify代码重排序
                    System.out.println("线程3 调用notify");
                    object.notify(); //2
                    System.out.println("线程3 调用完notify后，休息一会");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                    }
                    System.out.println("线程3 休息够了，结束同步代码块");
                }
            }
        }, "线程3").start();
    }
}

测试结果

线程1 获取到监视器锁
线程2 获取到监视器锁
线程3 拿到了监视器锁。
线程3 设置线程1中断
线程3 调用notify
线程3 调用完notify后，休息一会
线程3 休息够了，结束同步代码块
线程2 正常恢复啦。
线程1 wait方法抛出了InterruptedException异常

Sleep休眠

作用：使当前正在执行的线程休眠指定的一段时间（暂时停止执行任何指令）
休眠期间，线程不会释放任何的监视器锁

Yield礼让

作用：yield 是告诉操作系统的调度器：我的cpu可以先让给其他线程。注意，调度器可以不理会这个信息。

这个方法太鸡肋，几乎没用。

plumblum
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的线程等待与通知相关方法await，notify等
weixin_46539949的博客
10-06 833
（1）wait函数 调用wait方法后，线程被阻塞挂起，直到其他线程调用了notify()或notifyAll()后返回，其他线程调用了interrupt()方法，抛出InterruptedException异常返回。如果调用wait()方法前没有获取到该对象的监视器锁，则会抛出IllegalMonitorException异常 synchronized(queue){ //防止虚假唤醒，对queue资源进行循环检测，直到满足条件后才执行后面的add操作 while(queue.siz...
多线程wait、yield、sleep、join详解
echo.T的博客
09-13 1623
wait、yield、sleep详解
Java线程和并发 - Waiting and Notification
weixin_43364172的博客
01-14 173
Java线程和并发 - Waiting and NotificationWait-and-Notify API生产者和消费者 Java提供了线程间通信的API-一个线程可以等一个条件继续执行，在未来，另一个线程会增加该条件，然后提醒等待中的线程。。 Wait-and-Notify API Object类提供了Wait-and-Notify API，由三个wait()方法、一个notify()方法还...
Thread Management
OgOg
11-11 259
From http://jikesrvm.org/Thread+Management Thread Management This section provides some explanation of how Java™ threads are scheduled and synchronized by Jikes™ RVM. All Java threads (appl...
Notification使用详解之二：可更新进度的通知
大猴子的学习园地
07-28 743
上次和大家分享了关于Notification的基础应用，包括简单的通知和自定义视图的通知。今天和大家分享一下如何实现一个可更新进度的通知。 我们将会模拟一个下载任务，先启动一个线程负责模拟下载工作，在这个过程中更新进度信息，然后下载线程把最新的进度信息以消息的形式，发送到UI线程的消息队列中，最后UI线程负责根据最新的进度信息来更新进度通知的UI界面。 好，大概就是这个步骤。接下来我们
Java线程详解：wait、notify、notifyAll、join
liu_shi_jun的专栏
04-22 1295
线程的概念 线程是进程的子任务，一个进程可以创建多个线程，线程不拥有系统资源，但是线程可以共享进程的资源，而线程自己也有一块独立的小块空间：包括堆栈，程序计数器和局部变量。 线程是CPU调度和分派的基本单位。在同一时刻cpu只能执行一段代码，或者说叫一段顺序执行流，也就是线程。cpu在不同的线程之间来回切换，因为cpu的运行速度非常高，看起来就像这些线程一起执行一样，这就是并发。 线程状态 ...
深入剖析Sleep、wait、notify、notifyAll、yield、join、Interrupt
路漫漫，水迢迢
05-13 1813
sleep原理sleep是Thread类中的静态方法，首先看下sleep的源码/** * Causes the currently executing thread to sleep (temporarily cease * execution) for the specified number of milliseconds, subject to * the pre
iOS开发之Notification与多线程
kidd风的博客
03-13 2679
一、概述 在多线程中，无论在哪个线程注册了观察者，Notification接收和处理都是在发送Notification的线程中的。所以，当我们需要在接收到Notification后作出更新UI操作的话，就需要考虑线程的问题了，如果在子线程中发送Notification，想要在接收到Notification后更新UI的话就要切换回到主线程。先看一个例子：
Java基础——Java多线程中sleep()、wait()和notify()
Davis
11-02 7750
一、sleep()sleep()方法源码： /** * Causes the currently executing thread to sleep (temporarily cease * execution) for the specified number of milliseconds, subject to * the precision and acc...
sleep()方法和wait()方法的比较
iCoding91
02-26 1470
sleep()方法 VS wait() 方法 释放锁： 不释放； 释放。 归属对象： Thread的static方法; Object的方法。 调用前后的影响： sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用，目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为...
Android Notification使用方法详解
08-30
主要介绍了Android Notification使用详解的相关资料,需要的朋友可以参考下
android 通知Notification详解及实例代码
08-31
Notification是Android系统提供的一种机制，用于在状态栏中显示信息，即使应用不在前台也能吸引用户的注意力。下面我们将详细讲解Android通知Notification，并给出实例代码。 1. **创建Notification** 创建...
Android中关于Notification及NotificationManger的详解
09-05
在Android应用开发中，Notification和NotificationManager是两个关键组件，用于在系统状态栏显示非侵入性的用户提醒。本文将详细解析这两个组件的工作原理和使用方法。 首先，Notification是Android系统提供的一种...
Android Notification 使用方法详解
08-29
Android Notification 使用方法详解 Android Notification 是 Android 系统中的一种重要组件，用于向用户显示重要信息和提示。Android Notification 使用方法详解中，我们将介绍如何使用 Android Notification ...
voliate原理
plumblum的博客
12-18 6985
volatile原理 volatile 当使用volatile关键字修饰共享变量(实例变量、静态变量)时，它将具备两个特性：可见性和禁止指令重排序优化 1.可见性 变量被修改后，会立即保存在主存中，并清除工作内存中的值。 新值对于线程来说都是可见的。 2.禁止指令重排序优化 指令重排序是指CPU在正确处理指令依赖(数据依赖)并且保障程序执行得到正确结果的情况下，调整代码的执行顺序，允许将多...
2.3四种线程连接池的配置和使用（和自定义线程池）
plumblum的博客
11-12 693
四种线程连接池的配置和使用 最终调用类和方法 {参数有 核心线程数目，最大线程数目，存活时间（当前线程执行完这个任务之后，等待下一个任务到来的最长等待时间。如果在这个时间内没有新的任务来到，那当前线程就会退出），时间单位，等待队列（用于存放待执行的任务）} public ThreadPoolExecutor( // 核心线程数目 int corePoolSize, //最大线程数目 int max...
Java读写锁
plumblum的博客
02-07 418
1.读写锁的使用 写的时候使用锁 读的时候不使用锁   public class ReadWrite { private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); private Lock readLock; private Lock writeLock; private int...
2.2四种线程连接池的作用
plumblum的博客
11-12 319
四种线程连接池的作用及其使用 线程池的作用： 线程池作用就是限制系统中执行线程的数量。 根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排 队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池 中有等待...
CountDownLatch和CyclicBarrier的区别
plumblum的博客
02-14 301
CountDownLatch和CyclicBarrier的区别   从字面上理解，CountDown表示减法计数，Latch表示门闩的意思，计数为0的时候就可以打开门闩了。Cyclic Barrier表示循环的障碍物。两个类都含有这一个意思：对应的线程都完成工作之后再进行下一步动作，也就是大家都准备好之后再进行下一步。然而两者最大的区别是，进行下一步动作的动作实施者是不一样的。这里的“动作实施者”...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值