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

已于 2024-03-27 20:19:43 修改
阅读量782 收藏 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例程练习（多线程[sleep()方法]）
Yours风之恋 ~~~~~
05-04 815
import java.util.*; public class Test { public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); try { Thread.sleep(10000);//主线程睡眠 } catch(Interrupted
Java-多线程-sleep方法
yy310585的博客
01-17 182
Java-多线程-sleep方法 Thread的sleep方法，可以认为得制造线程的阻塞，阻塞的时间就是传入的参数的时长，单位为毫秒 示例： public class Test02 { // 这是main方法，实现程序主要逻辑 public static void main(String[] args) { // 定义一个时间格式 ...
Java多线程之sleep
weixin_54963748的博客
01-02 4259
Java多线程之sleep
Java多线程基础（一）——线程与锁
weixin_33991727的博客
07-06 309
一、线程的基本概念 1.1 单线程 简单的说，单线程就是进程中只有一个线程。单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。 Java示例： public class SingleThread { public static void main(String[] args) { ...
java线程的notify_java线程notify(), wait()的使用
weixin_34577501的博客
02-20 366
回顾一个比较经典的线程间协作的问题：启动三个线程，每个线程相应的打印10遍A，10遍B，10遍C。要求三个线程交替执行，输处10遍ABC。用Object类的notify(), wait()方法可实现上述要求。Object.notify()可以唤醒一个线程，使之进入就绪状态，等待获取对象锁后运行。Object.wait()方法可以使一个线程进入阻塞状态，然后释放对象锁，等待被notify()方法唤醒...
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 notifyall_Java Thread notifyAll()方法
weixin_29943753的博客
02-21 236
Thread类的notifyAll()方法用于唤醒所有线程。此方法向特定对象的所有等待线程发出通知。如果使用notifyAll()方法并且多个线程正在等待通知，那么所有线程都会收到通知，但线程的执行将逐个执行，因为线程需要锁定，并且只有一个锁可用于一个对象。语法public final void notifyAll()返回此方法不返回任何值。异常IllegalMonitorStateExcepti...
java wait 函数_java 线程 Thread 使用介绍，包含wait(),notifyAll() 等函数使用介绍
weixin_30096975的博客
02-16 174
(原创，转载请说明出处！谢谢--http://www.cnblogs.com/linguanh/)此文目的为了帮助大家较全面、通俗地了解线程 Thread 相关基础知识！目录：--线程的创建：--启动线程--线程的调度--Thread 类的简介--线程的同步/异步--wait() 和 notify(),notifyAll()方法在讲线程之前，先说下进程。进程:是运行系统中，每个独立运行的程序。例如...
java thread.notify_Java Thread wait、notify与notifyAll
weixin_42499004的博客
02-13 236
Java的Object类包含了三个final方法，允许线程就资源的锁定状态进行通信。这三个方法分别是：wait(),notify(),notifyAll()，今天来了解一下这三个方法。在任何对象上调用这些方法的当前线程应具有对象监视器(锁住了一个对象，就是获得对象相关联的监视器)，否则会抛出java.lang.IllegalMonitorStateException异常。waitObject.wa...
Java多线程中notifyAll()方法使用教程
热门推荐
五道口
10-27 1万+
1.`notifyAll()`中`All`的含义是所有的线程，而不是所有的锁，只能唤醒等待（调用wait()方法等待）同一个锁的所有线程，这一点一定要注意。 2.`notifyAll()`必须在当前线程拥有监视器锁的情况下执行，否则将抛出异常`IllegalMonitorStateException`。意思是说必须在同步代码块中，调用此方法，否则可能出现在没有得到锁的情况下，执行了此方法，导致程序异常。`wait()`和`notify()`系列方法这样设计的目的是防止死锁或永久等待发生。
Java Thread等待，通知和notifyAll示例
从零开始的教程世界
07-07 166
The Object class in java contains three final methods that allows threads to communicate about the lock status of a resource. These methods are wait(), notify() and notifyAll(). So today we will look ...
Java并发编程(五)——wait、notify/notifyAll、sleep深入剖析
程序员资料站
05-08 283
前言 先看一段代码， class BlockingQueue { Queue<String> buffer = new LinkedList<>(); public synchronized void give(String s) { this.buffer.add(s); } public synchronized String take() { while (buffer.isEmpty()) { }
notify与notifyAll的区别，sleep与wait的区别
weixin_45818037的博客
08-04 211
目录 一、notify与notifyAll的区别 二、sleep与wait的区别 一、notify与notifyAll的区别 锁池： 　　假设线程A已经拥有对象锁，线程B、C想要获取锁就会被阻塞，进入一个地方去等待锁，这个地方就是该对象的锁池； 等待池： 　　假设线程A调用某个对象的wait方法，线程A就会释放该对象锁，同时线程A进入该对象的等待池中，进入等待池中的线程不会去竞争该对象的锁。 1、notify只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会； 2、noti.
Java多线程-wait、notify、notifyAll和sleep的区别和联系
damo的博客
03-01 261
一、等待唤醒机制 1.1 线程间通信
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、付费专栏及课程。

余额充值