Java 多线程的wait,notify,notifyAll,sleep,interrupt方法

已于 2024-03-27 20:19:43 修改
阅读量783 收藏 9
点赞数 24
文章标签： java 开发语言
于 2024-03-27 19:21:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59276831/article/details/137084895
版权

1. wait(),notify(),notifyAll()方法。

wait()、notify()和notifyAll()这三个方法都依赖于Java对象的监视器锁（也称为内置锁或互斥锁）。调用这些方法时，当前线程必须持有该对象的监视器锁，所以通常它们三都与synchronized 关键字一起使用，否则将抛出IllegalMonitorStateException异常(也就是没有获取对象的监视器锁和调用了这些方法)。这里我们以wait(),notify(),notifyAll()为主线，然后穿插对于sleep的区别和interrupt的应用。

1.1. wait()方法

1.1.1 释放锁

当线程调用对象的wait()方法时，它会释放该对象的监视器锁。这允许其他线程能够进入同步代码块或方法，并获得锁以执行其操作。（与此相反sleep方法不会释放监视器锁）

如下：

  • 我们将第一个线程Chinese先启动后，
  • 再将主线程sleep睡2s确保Chinese一定是在第二个线程Math前启动的。
  • 但是是我们在第一个线程Chinese中等待5s，同时
  • 启动第二个线程，可以看到第二个线程Match的结果是先被输出的，所以wait方法会释放锁
public class studyClass {
    public static void main(String[] args) {
        Object object = new Object();
        Chinese chinese = new Chinese(object);
        Math math = new Math(object);
        Thread tChi = new Thread(chinese);
        Thread tMatch = new Thread(math);
        tChi.start();
        try{
            Thread.sleep(2000);
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }
        tMatch.start();
    }
}

//---------------------------------------------------------
class Chinese implements Runnable{
    private Object object;

    public Chinese(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            try{
                object.wait(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print("<C ");
            System.out.print("C> ");
        }
    }
}

//---------------------------------------------------------
class Math implements Runnable{
    private Object object;

    public Math(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            System.out.print("<M ");
            System.out.print("M> ");
        }
    }
}

object.wait(5000); 的结果

如果我们将Chinese 子线程中的的object.wait(5000); 改为Thread.sleep(5000);得到的结果为如下，说明sleep方法是不会释放锁的。

 1.1.2. 等待与通知

wait()方法通常与notify()或notifyAll()方法一起使用，以在多个线程之间实现协作。一个线程可以调用wait()来等待某个条件成立，而另一个线程可以在条件成立后调用notify()或notifyAll()来唤醒在等待的线程。

如下：

  • 我们将第一个子线程Chinese先启动
  • 主线程先睡1s后
  • 再启动第二个线程Match，确保第一个线程启动后一定就进入wait。
  • 可以看到输出结果是第二个线程Match的，在它输出完成后调用了notify()后。
  • 第一个线程的wait才结束的并输出第一个线程的结果。
public class studyClass {
    public static void main(String[] args) {
        Object object = new Object();
        Chinese chinese = new Chinese(object);
        Math math = new Math(object);
        Thread tChi = new Thread(chinese);
        Thread tMatch = new Thread(math);
        tChi.start();
        try{
            Thread.sleep(1000);
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }
        tMatch.start();

    }
}

//---------------------------------------------------------
class Chinese implements Runnable{
    private Object object;

    public Chinese(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            try{
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print("<C ");
            System.out.print("C> ");
        }
    }
}

//---------------------------------------------------------
class Math implements Runnable{
    private Object object;

    public Math(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            System.out.print("<M ");
            System.out.print("M> ");
            object.notify();
        }
    }
}

 1.1.3. 可中断

调用wait()方法等待的线程可以通过调用其interrupt()方法被中断。如果线程在等待时被中断，wait()方法将抛出InterruptedException异常。 

如下：

  • 方法我们在第一个子线程Chinese进入wait(5000)
  • 紧接着在主方法中让第一个子线程Chinese中断
  • 测试结果还是立马会中断并继续执行未执行完的代码，而不会继续wait直到5s，可与1.1.1对比可知。
    (wait方法会释放锁，中断后立马再次获取锁，然后在执行接下来的代码，sleep的中断和wait类似，这里不在举例）
public class studyClass {
    public static void main(String[] args) {
        Object object = new Object();
        Chinese chinese = new Chinese(object);
        Math math = new Math(object);
        Thread tChi = new Thread(chinese);
        Thread tMatch = new Thread(math);
        tChi.start();
        tChi.interrupt();
        tMatch.start();

    }
}

//---------------------------------------------------------
class Chinese implements Runnable{
    private Object object;

    public Chinese(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            try{
                object.wait(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print("<C ");
            System.out.print("C> ");
        }
    }
}

//---------------------------------------------------------
class Math implements Runnable{
    private Object object;

    public Math(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            System.out.print("<M ");
            System.out.print("M> ");
        }
    }
}

1.2.  notify(),notifyAll()方法

1.2.1.  等待队列与同步队列：

 notify（或notifyAll）方法会将等待队列中的一个（或多个）线程移到同步队列中，但并不立即将其激活。只有当该线程重新获取到对象锁后，它才会真正从wait()方法返回并继续执行。

如下我们将

  1. 第一个子线程Chinse先启动，但启动后进入wait状态
  2. 第二个子线程Match再启动，
  3. 第二个子线程启动后输出一个<M后立马notify，但是nofity后面还需要输出10万次M
  4. 我们可以看到结果，第二个子线程并没有立马将第一个子线程激活而是将自身的事情做完了（输出了10万个M) 才释放的锁并让第一个子线程执行。所以nofity或nofityAll并不会释放锁。
public class studyClass {
    public static void main(String[] args) {
        Object object = new Object();
        Chinese chinese = new Chinese(object);
        Math math = new Math(object);
        Thread tChi = new Thread(chinese);
        Thread tMatch = new Thread(math);
        tChi.start();
        try{
            Thread.sleep(1000);
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }
        tMatch.start();

    }
}

//---------------------------------------------------------
class Chinese implements Runnable{
    private Object object;

    public Chinese(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            try{
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print("<C ");
            System.out.print("C> ");
        }
    }
}

//---------------------------------------------------------
class Math implements Runnable{
    private Object object;

    public Math(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            System.out.print("<M ");
            object.notify();
            for (int i = 0; i<100000;i++){
                System.out.print("M");
            }
            System.out.print("M> ");
        }
    }
}

 1.2.2. 随机性：

notify()方法随机唤醒等待队列中的一个线程，所以你不能控制具体哪个线程会被唤醒。如果你需要唤醒所有等待的线程，应该使用notifyAll()方法。

1.2.3 notify(),notifyAll()区别

notfiy 随机通知其中一个线程，notifyAll同时所以线程。
如下有三个子线程 Chinese、Math、English。

  • 我们先执行第一个子线程Chinese，并让他进入等待状态。
  • 再执行第二个子线程Match，同样让它进入等待状态。
  • 再执行地三个子线程English但不wait，等它执行完后再调用notify()或notifyAll()方法。
public class studyClass {
    public static void main(String[] args) {
        Object object = new Object();
        Chinese chinese = new Chinese(object);
        Math math = new Math(object);
        English english = new English(object);
        Thread tChi = new Thread(chinese);
        Thread tMatch = new Thread(math);
        Thread tEng = new Thread(english);
        tChi.start();
        tMatch.start();
        try{
            Thread.sleep(1000);
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }
        tEng.start();
    }
}
//---------------------------------------------------------
class Chinese implements Runnable{
    private Object object;

    public Chinese(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            try{
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print("<C ");
            System.out.print("C> ");
        }
    }
}
//---------------------------------------------------------
class Math implements Runnable{
    private Object object;

    public Math(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            try{
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print("<M ");
            System.out.print("M> ");
        }
    }
}
//---------------------------------------------------------
class English implements Runnable{
    private Object object;

    public English(Object object){
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {
            System.out.print("<E ");
            object.notify();
            System.out.print("E> ");
        }
    }
}

notfiy()方法的结果。永远是通知其中一个wait方法，而另外一个wait方法还是在wait下去


将代码中的object.notify();改为object.notifyAll();

TGO-Ming
关注
  • 24
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java多线程应用中常用的sleep、yield、join、wait、notify、notifyAll方法介绍
yh_zeng2的博客
01-18 642
1）Thread.sleep()/sleep(long millis) 当前线程睡眠/millis的时间（millis指定睡眠时间是其最小的不执行时间，因为sleep(millis)休眠到达后，无法保证会被JVM立即调度）；sleep()是一个静态方法(static method) ，所以他不会停止其他的线程也处于休眠状态；线程sleep()时不会失去拥有的对象锁。 作用：保持对象锁，让出C
Java多线程研究03-线程的基本操作（notify，notifyAll，interrupt，join，sleep）
一名java从业者的专栏
07-24 1645
JAVA中的基本线程操作这是前面给出的线程状态切换图例，可能还不能完全理解其中的切换条件，我们将详细介绍JAVA中如何进行这些线程状态的操作。 本文将讲解notify、notifyAll、interrupt、join和sleep等操作。notify和notifyAll操作notify方法的工作情况通过代码解释：package com.zczpeng.thread;public class Noti
Java多线程之sleep
weixin_54963748的博客
01-02 4259
Java多线程之sleep
Java多线程——wait和notify方法作用，线程的状态，作为软件测试开发程序员
2401_84253380的博客
04-15 1092
线程过多会带来额外的开销，频繁创建和销毁大量线程需要占用系统资源，消耗大量时间。其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。
Java多线程——线程的sleep方法、中断线程的睡眠
Best_Basic的博客
08-22 5406
Java多线程——线程的sleep方法、中断线程的睡眠。 sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。
Java多线程的sleep（休眠）
weixin_47556601的博客
02-23 1万+
大家好，今天分享Java多线程的sleep（休眠） 了解这样的几个概念： 1.sleep指向当前线程阻塞的毫秒数（就是可以让线程停一会） 2.sleep 存在异常 InterruptedException 3.sleep 时间达到后线程进入就绪状态 4.sleep 可以模拟网络延时，倒计时等 5.sleep 每一个对象都有一个锁，sleep 不会释放锁 写源码： package Demo04; public class TestSleep implements Runnable{ //使用Run
【java】多线程sleep和终断基本方法
weixin_52099341的博客
06-30 1034
实现线程的两种方式：第一种： 第二种： 基本操作： sleep方法： 终断线程睡眠： 终止线程执行：
java多线程面试题59题集合
03-15
- wait(), notify(), notifyAll()：Object类的方法，用于线程间通信，必须在同步环境中使用。 4. **死锁** - 死锁定义：两个或更多线程相互等待对方释放资源，导致无法继续执行。 - 死锁避免：避免循环等待，...
Java线程中sleep和wait的区别详细介绍
09-05
Java线程中的`sleep()`和`wait()`方法都是在多线程环境中用于控制线程执行的重要工具，但它们之间存在着显著的区别。理解这些差异对于编写高效、正确的并发代码至关重要。 首先，Java的多线程机制基于抢占式模型，...
实例总结Java多线程编程的方法
08-26
Java多线程编程是开发高并发、高性能应用的关键技术之一。在Java中，有多种方式来创建和管理线程，本文将对这些方法进行详细解释，并通过实例代码展示其使用。 1. **何时使用多线程编程** 当程序中有多个独立的...
JAVA多线程共13页.pdf.zip
11-21
此外，还有wait()、notify()和notifyAll()方法配合使用。 6. **死锁**：当两个或更多线程互相等待对方释放资源而形成的一种僵局。避免死锁的关键在于避免循环等待，合理设计资源获取顺序。 7. **线程优先级**：...
java_Thread.rar_java 多线程_java多线程
09-21
线程间的通信主要依靠wait()、notify()和notifyAll()方法，这些方法位于Object类中，它们需要在同步控制块或同步方法内使用，以避免死锁和活锁等问题。 在实际开发中，还需要考虑线程安全问题，例如避免脏读、幻读...
Java多线程 notify 与notifyAll的区别
Java持续实践
08-29 328
文章目录notify 与notifyAll的区别 notify 与notifyAll的区别 如下的代码, 首先演示了notifyAll 来唤醒全部的线程. 创建了两个线程A和B. 分别去获得锁, 并且调用wait方法释放锁. 紧接着 线程C 调用了notifyAll方法, 来唤醒 处于wait状态的所有线程. 同时,为了保证线程的执行顺序, 即为了保证调用唤醒notifyAll方法的时候, 所有的线程, 都是处于wait状态, 在启动了线程A和B之后, 启动线程c之前, 调用了sleep方法来保证线程执行
Java线程基础(13):wait()和notify()
mingyuli的博客
07-21 1万+
简介 本文讲解Java中wait()、notify()，通过一个标准的使用实例，来讨论下这两个方法的作用和使用时注意点，这两个方法被提取到顶级父类Object对象中，地位等同于toString()方法。 一、wait()和notify()含义 wait()方法是让当前线程等待的，即让线程释放了对共享对象的锁，不再继续向下执行。 wait(long timeout)方法可以指定一个超时时间，过了这个时间如果没有被notify()唤醒，则函数还是会返回。如果传递一个负数timeout会抛出I...
JAVA多线程-线程间通信(一)-等待/通知机制（wait/notify）
绝版灬小伙的博客
02-20 6205
线程间通信     线程与线程之间不是独立的个体，它们彼此之间可以相互通信与协作。     线程间通信后，系统之间的交互性会更强大，在大大提交CPU利用率的同时，还会使程序要对各线程任务在处理的过程中进行有效的把控和监督。     学习目录：     一、使用wait/notify实现线程间的通信     二、生产者/消费者模式的实现     三、方法join的使用     四、
java线程的wait方法和notify方法的运用
热门推荐
记录和分享程序人生的点点滴滴
10-01 3万+
一. java Thread类的几个函数的说明： 　1.  setPriority( ): 设置线程的优先权;     2 . yield( ): 暂停线程的执行，给其它具有相同优先权的线程执行的机会，若此时没有其它线程执行，则此线程继续执行。这个函数并不会释放锁住的对象。 　3.  join( ): 等待加入的线程执行完毕才会执行下一个线程。加入的线程通过interrupt( )来唤醒。
java线程学习(四)：线程等待wait()和通知notify()的详细使用
shenhaiyushitiaoyu的博客
12-17 7006
线程等待wait()和通知notify()，主要用于多线程之间的协作，而且这两个方法都是属于Object类，说明任何对象都可以调用这两个方法。 当在一个对象实例上调用wait()方法后，当前线程就会在这个对象上等待。直到另外的线程调用了notify()方法，出于等待的线程才得以继续进行。这样，多线程之间的协作就可以用这两个方法进行通信了。 先看下例子： package stop_demo; pu...
JAVA线程同步中wait()和notify()运用例子
Shawn的博客
02-24 1356
看后感觉不错，本文转载自百度文库https://wenku.baidu.com/view/403cc42c8e9951e79b8927ac.html JAVA线程同步中wait()和notify()例子 搞懂这两个的用法之前，请你务必搞懂线程同步的道理，否则，下面这一大篇你应该是看不懂的。 wait()和notify()一系列的方法，是属于对象的，不是属于线程的。它们用在线程同步时，s...
Java内存模型
最新发布
weixin_44267758的博客
07-19 663
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
java多线程中的wait和sleep的区别
03-11
在Java多线程中，wait和sleep都可以暂停线程的执行。不同的是，wait是Object类的方法，而sleep是Thread类的方法。wait方法会释放对象的锁，而sleep方法不会释放锁。另外，wait方法需要在同步代码块中使用，而sleep方法可以在任何地方使用。wait方法需要被notify或notifyAll方法唤醒，而sleep方法可以通过时间或者interrupt方法唤醒。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值