Java多线程技术二：线程间通信——wait/notify机制

最新推荐文章于 2024-08-24 22:01:16 发布
最新推荐文章于 2024-08-24 22:01:16 发布
阅读量1.2k 收藏 24
点赞数 33
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geminigoth/article/details/134700751
版权
本文详细探讨了线程间的通信，特别是通过wait/notify机制实现线程间的协作，指出不使用wait/notify的缺点，解释了wait/notify的工作原理、基本用法以及如何在业务代码中封装。还讨论了线程状态的切换和不同方法（如wait/sleep/notify/notifyAll）对锁释放的影响。
摘要由CSDN通过智能技术生成

1 概述

        线程时操作系统中独立的个体，但这些个体如果不经过特殊的处理是不能成为一个整体的。线程间的通信就是使线程成为整体的比用方案之一，可以说，是线程间进行通信后系统之间的交互性会更强大，CPU利用率会得以大幅提高，同时程序员在处理的过程中可以有效把控与监督各线程任务。

2 不使用wait/notify机制进行通信的缺点

public class MyList {
    volatile private List list = new ArrayList<>();
    public void add(){
        list.add("jay chou");
    }
    public int size(){
        return list.size();
    }

}

  

public class ThreadA extends Thread{
    private MyList list;

    public ThreadA(MyList list) {
        this.list = list;
    }

    @Override
    public void run(){
        try {
            for (int i = 0; i < 10; i++) {
                list.add();
                System.out.println("添加了" + (i + 1) +"个元素");
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class ThreadB extends Thread{
    private MyList list;

    public ThreadB(MyList list) {
        this.list = list;
    }

    @Override
    public void run(){
        try {
            while(true){
                if(list.size() == 5){
                    System.out.println(" == 5了，线程b要退出了");
                    throw new InterruptedException();
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class Run1 {
    public static void main(String[] args) {
        MyList list = new MyList();
        ThreadA a = new ThreadA(list);
        a.setName("a");
        a.start();
        ThreadB b = new ThreadB(list);
        b.setName("b");
        b.start();
    }
}

      

        虽然两个线程之间实现了通信，但还存在缺点：线程ThreadB不停地通过while语句轮询机制来检测某一个条件，这样会浪费CPU资源。如果轮询的时间间隔很短，更浪费CPU资源；如果轮询的时间很长，有可能会取不到想要得到的数据。

3 什么是wait/notify机制

         wait/notify（等待/通知）机制在生活中很常见，比如在就餐时就会出现，如下图：

        厨师和服务员在”菜品传递台“上交互，在这期间会想到几个问题：

        1、厨师做完一个菜的时间未知，所以厨师把菜品放到”菜品传递台“上的时间也未知。

        2、服务员取到菜的时间取决于厨师，所以服务器就有”wait“的状态。

        3、服务器如何能取到菜？这又要取决于厨师。厨师将菜放到”菜品传递台“上，其实就相当于一个notify，这时服务员才可以拿到菜并交给就餐者。

        4、这个过程中就出现了”wait/notify“机制。

        需要说明的是，前文中多个线程之间也可以实现通信，就是就是多个线程共同访问同一个变量。但那种通信机制却不是”等待/通知“,两个线程完全是主动操作同一个共享变量。 但那种通信机制却不失“等待/通知”,两个线程完全是主动操作同一个共享变量，在花费读取时间的基础上，读到的值并不确定是不是想要的。

4 wait/notify机制的原理

        注意：拥有相同锁的线程才可以实现wait/notify机制。所以下文都是假定操作同一个锁。

        wait()是Object类的方法，它的作用是使当前执行wait()方法的线程进行等待，在wait()所在的代码行处暂停执行，并释放锁，直到接到通知或被中断为止。在调用wait()之前，线程必须要获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。通过通知机制是某个线程继续执行wait()方法后面的代码时，对线程的选择是按照执行wait()方法的顺序确定的，并需要重新获得锁。如果调用wait()时没有持有适当的锁，则抛出IllegalMonitorStateException。它是RuntimeException的一个子类，因此不需要try-catch语句进行捕获异常。

        notify()也要在同步方法或同步块中调用，即在调用前线程必须要获得锁，如果调用notify()没有持有适当的锁，也会抛出IllegalMonitorStateException。该方法用来通知哪些可能等待该锁的其他线程，如果有多个线程等待，则按照执行wait()方法的顺序对呈等待状态的线程发出1次通知，并使那个线程重新获取锁。需要说明的是，执行notify()方法后，当前线程不会马上释放锁，呈等待状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步区域后，当前线程才会释放锁，而呈等待状态所在的线程才可以获取该对象锁。当第一个获得了该对象锁的等待线程运行完毕后，它会释放掉该对象锁。此时如果没有再次使用notify语句，那么其他等待状态的线程会因为没有得到通知而继续等待。

        wait和notify是Object类中的方法。总结来说：wait是线程暂停运行，而notify通知暂停的线程继续运行。

5 wait()的基本用法

        wait()的作用是使当前线程暂停运行，并释放锁。   

public class Test1 {
    public static void main(String[] args) {
        try {
            String s = new String("");
            s.wait();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

        出现异常的原因是没有“对象监视器”,也就是没有锁。

public class Test2 {
    public static void main(String[] args) {
        try {
            String lock = new String();
            System.out.println("synchronzied之前");
            synchronized (lock){
                System.out.println("进入synchronzied代码块");
                lock.wait();
                System.out.println("执行完wait()方法");
            }
            System.out.println("执行完synchronzied代码块的代码");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

 

        此时线程已经开始等待，但不能永远等待下去，否则程序就不会继续向下运行了。使用notify()方法可以是等待状态的线程继续运行。

6 实现wait/notify机制

public class MyThread1 extends Thread{
    private Object lock;

    public MyThread1(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run(){
        try {
            synchronized (lock){
                System.out.println("开始 等待时间 = " + Utils.data(System.currentTimeMillis()));
                lock.wait();
                System.out.println("结束 等待时间 = " + Utils.data(System.currentTimeMillis()));
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class MyThread2 extends Thread{
    private Object lock;

    public MyThread2(Object lock) {
        this.lock = lock;
    }
    @Override
    public void run(){
        synchronized (lock){
            System.out.println("开始 通知时间 = " + Utils.data(System.currentTimeMillis()));
            lock.notify();
            System.out.println("结束 通知时间 = " + Utils.data(System.currentTimeMillis()));
        }

    }
}
public class Run1 {
    public static void main(String[] args) {
        try {
            Object object = new Object();
            MyThread1 t1 = new MyThread1(object);
            t1.start();
            Thread.sleep(3000);
            MyThread2 t2 = new MyThread2(object);
            t2.start();
        }catch (InterruptedException e){
            e.printStackTrace();
        }

    }
}

        从运行结果来看，3秒后线程被通知唤醒。

7 使用wait/notify实现线程销毁

        使用wait/notify可以在某个特定条件下，销毁线程。

public class MyList {
    private static List list= new ArrayList<>();
    public static void add(){
        list.add("1");
    }

    public static int size(){
        return list.size();
    }
}


public class ThreadA extends Thread{
    private Object lock;

    public ThreadA(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run(){
        try {
            synchronized (lock){
                if(MyList.size() != 5){
                    System.out.println("开始等待 = " + Utils.data(System.currentTimeMillis()));
                    lock.wait();
                    System.out.println("结束等待 = " + Utils.data(System.currentTimeMillis()));
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class ThreadB extends Thread{
    private Object lock;

    public ThreadB(Object lock) {
        this.lock = lock;
    }
    @Override
    public void run(){
        try {
            synchronized (lock){
                for (int i = 0; i < 10; i++) {
                    MyList.add();
                    if(MyList.size() == 5){
                        lock.notify();
                        System.out.println("已发出通知");
                    }
                    System.out.println("添加了 " + (i+1));
                    Thread.sleep(1000);
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class Run1 {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        ThreadA t1 = new ThreadA(lock);
        t1.start();
        Thread.sleep(50);
        ThreadB t2 = new ThreadB(lock);
        t2.start();

    }
}

        日志信息“结束等待”在最后输出，这也说明notify()方法执行后并不立即释放锁，这点后面会补充介绍。

        关键字synchronzied可以将任何一个Object作为锁来看待，而Java为每个Object都实现了wait()和notify()方法，它们必须用在被同步的Object的临界区内。通过调用wait()方法可以使处于临界区内的线程进入等待状态，同时释放被同步对象的锁，而notify操作可以唤醒一个由于调用了wait操作而处于wait状态中的线程，使其进入就绪状态，被重新唤醒的线程会试图重新获取临界区的控制权，也就是锁，并继续执行临界区内wait之后的代码。如果发出notify操作时没有处于wait状态中的线程，那么该命令就会被忽略。

        notify()方法按照执行wait方法的顺序唤醒等待同一个锁的“一个”线程，进入可运行状态。也就是notify()方法仅通知“一个”线程。而notifyAll()方法执行后，会按照执行 wait()方法的倒序依次唤醒全部的线程。

8 对业务代码进行凤封装

        前面的代码是在自定义的类中处理业务，而业务代码要尽量放在Service类中进行处理。

public class MyList {
    volatile private List list = new ArrayList<>();
    public void add(){
        list.add("q");
    }
    public int size(){
        return list.size();
    }
}


public class MyService {
    private Object lock = new Object();
    private MyList list = new MyList();
    
    public void watiMethod(){
        try {
            synchronized (lock){
                if(list.size() != 5){
                    System.out.println("开始等待 = " + Utils.data(System.currentTimeMillis()) + " " + Thread.currentThread().getName());
                    lock.wait();
                    System.out.println("结束等待 = " + Utils.data(System.currentTimeMillis()) + " " + Thread.currentThread().getName());
                    
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    
    public void notifyMethod(){
        try {
            synchronized (lock){
                System.out.println("开始通知 = " + Utils.data(System.currentTimeMillis()) + " " + Thread.currentThread().getName());
                for (int i = 0; i < 10; i++) {
                    list.add();
                    if(list.size() == 5){
                        lock.notify();
                        System.out.println("发出通知，wait后面的代码还没有立即执行，因为锁没有释放");
                    }
                    System.out.println("add次数 " + (i+1));
                    Thread.sleep(1000);
                }

                System.out.println("结束通知 = " + Utils.data(System.currentTimeMillis()) + " " + Thread.currentThread().getName());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class ThreadA extends Thread{
    private MyService service;

    public ThreadA(MyService service) {
        this.service = service;
    }
    @Override
    public void run(){
        service.watiMethod();
    }
}
public class ThreadB extends Thread{
    private MyService service;

    public ThreadB(MyService service) {
        this.service = service;
    }

    @Override
    public void run(){
        service.notifyMethod();
    }
}

public class Run1 {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadA t1 = new ThreadA(service);
        t1.start();
        Thread.sleep(3000);
        ThreadB t2 = new ThreadB(service);
        t2.start();
    }
}

9 线程状态的切换 

        前面介绍了与Thread有关的大部分API，这些API可以改变线程对象的状态。

        1）创建了一个新的线程对象后，再调用它的start方法，系统会为此线程分配CPU资源，处于可运行状态，是一个准备运行的阶段。如果线程抢占到CPU资源，此线程就处于运行状态。

        2）可运行状态和运行状态可互相切换，因为有可能线程运行一段时间后其他高优先级的线程抢占了CPU资源，这时此线程就从运行状态变成可运行状态。

        线程进入可运行状态可分为以下四种情况：

        1、调用sleep()方法后经过的时间超过了指定的休眠时间；

        2、线程成功获得了试图同步的监视器；

        3、线程正在等待某个通知，其他线程发出了通知；

        4、处于挂起状态的线程调用了resume方法。

        3）暂停状态结束后，线程进入可运行状态，等待系统重新分配资源。

            出现阻塞的情况可分为以下5种：

                1、线程调用sleep方法，主动放弃占用的处理器资源；

                2、线程调用了阻塞式I/O方法，在该方法返回前，该线程被阻塞；

                3、线程试图获得一个同步监视器，但该监视器正被其他线程所持有；

                4、线程等待某个通知；

                5、程序调用了suspend方法将该线程挂起。此方法容易导致死锁，应尽量避免使用。

        4）run方法运行结束后进入销毁阶段，整个线程执行完毕。

10 wait()方法导致锁立即释放

        wait()被执行后，锁会被立即释放，但执行完notify方法后，锁不会立即释放。

public class Service {
    public void testMethod(Object lock){
        try {
            synchronized (lock){
                System.out.println("开始等待：");
                lock.wait();
                System.out.println("结束等待");
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class ThreadA extends Thread{
    private Object lock;

    public ThreadA(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run(){
        Service service = new Service();
        service.testMethod(lock);
    }
}
public class ThreadB extends Thread{
    private Object lock;

    public ThreadB(Object lock) {
        this.lock = lock;
    }
    @Override
    public void  run(){
        Service service = new Service();
        service.testMethod(lock);
    }
}


public class Run1 {
    public static void main(String[] args) {
        Object locl = new Object();
        ThreadA t1 = new ThreadA(locl);
        t1.start();
        ThreadB t2 = new ThreadB(locl);
        t2.start();
    }
}

              

11 sleep()方法不释放锁

        如果将wait方法改成sleep方法，就成了同步效果。

public class Service {
    public void testMethod(Object lock){
        try {
            synchronized (lock){
                System.out.println("开始等待：");
                Thread.sleep(4000);
                System.out.println("结束等待");
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

 

12 notify方法不立即释放锁

        还有一个结论要进行实验：方法notify被执行后，不立即释放锁。

public class MyService {
    private Object lock = new Object();
    public void testMethod(){
        try {
            synchronized (lock){
                System.out.println("开始等待时间 ： " + Utils.data(System.currentTimeMillis()) + Thread.currentThread().getName());
                lock.wait();
                System.out.println("结束等待时间 ： " + Utils.data(System.currentTimeMillis()) + Thread.currentThread().getName());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public void testNofity(){
        try {
            synchronized (lock){
                System.out.println("开始通知时间 ： " + Utils.data(System.currentTimeMillis()) + Thread.currentThread().getName());
                lock.notify();
                Thread.sleep(4000);
                System.out.println("结束通知时间 ： " + Utils.data(System.currentTimeMillis()) + Thread.currentThread().getName());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

     

public class ThreadA extends Thread{
    private MyService service;

    public ThreadA(MyService service) {
        this.service = service;
    }

    @Override
    public void run(){
        service.testMethod();
    }
}

     

public class ThreadB extends Thread{
    private MyService service;

    public ThreadB(MyService service) {
        this.service = service;
    }
    @Override
    public void  run(){
        service.testNofity();
    }
}

   

public class Run1 {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadA t1 = new ThreadA(service);
        t1.start();
        Thread.sleep(500);
        ThreadB t2 = new ThreadB(service);
        t2.start();
    }
}

通过控制台打印的时间来分析，得到的结论：必须执行完notify方法所在的同步代码块后，才释放锁。

13 notify方法只通知一个线程

        每次调用notify方法时，只通知一个线程进行唤醒，唤醒的顺序按执行wait方法的正序。

public class MyService {
    private Object lock = new Object();

    public void waitMethod(){
        try {
            synchronized (lock){
                System.out.println("开始等待时间 = " + Utils.data(System.currentTimeMillis()) + Thread.currentThread().getName());
                lock.wait();
                System.out.println("结束等待时间 = " + Utils.data(System.currentTimeMillis()) + Thread.currentThread().getName());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public void notifyMethod(){
        synchronized (lock){
            System.out.println("开始唤醒时间 = " + Utils.data(System.currentTimeMillis()) + Thread.currentThread().getName());
            lock.notify();
            System.out.println("结束唤醒时间 = " + Utils.data(System.currentTimeMillis()) + Thread.currentThread().getName());
        }
    }
}
public class ThreadA extends Thread{
    private MyService service;

    public ThreadA(MyService service) {
        this.service = service;
    }
    @Override
    public void run(){
        service.waitMethod();
    }
}
public class ThreadB extends Thread{
    private MyService service;

    public ThreadB(MyService service) {
        this.service = service;
    }

    @Override
    public void run(){
        service.notifyMethod();
    }
}

public class Run1 {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        for (int i = 0; i < 10; i++) {
            ThreadA t1 = new ThreadA(service);
            t1.start();
        }
        Thread.sleep(1000);
        ThreadB t1 = new ThreadB(service);
        t1.start();
        Thread.sleep(500);
        ThreadB t2 = new ThreadB(service);
        t2.start();
        Thread.sleep(500);
        ThreadB t3 = new ThreadB(service);
        t3.start();
        Thread.sleep(500);
        ThreadB t4 = new ThreadB(service);
        t4.start();
        Thread.sleep(500);
        ThreadB t5 = new ThreadB(service);
        t5.start();
    }

        通过以上几个实验，得出以下三个结论：
        1、执行完notify方法后，按照执行wait的顺序唤醒其他线程。notify所在的同步到代码块执行完才会释放对象的锁，其他线程继续执行wait之后的代码。

        2、在执行同步代码块的过程中，遇到异常而导致县城终止时，锁也会被释放。

        3、在执行同步代码块的过程中执行了锁所属对象的wait方法，这个线程会释放对象锁，等待被唤醒。

14 notifyAll方法通知所有线程

        前面示例中通过多次调用notify方法来实现5个线程被唤醒，当并不能保证实际系统中仅有5个线程，就是notify方法的调用次数小于线程对象的数量，那么会出现部分线程对象没有被唤醒的情况。为了唤醒全部线程，可以使用notifyAll方法。 

       注意，notifyAll方法会按照执行wait方法的倒序依次对其他线程进行唤醒。对上一节的MyService.java进行修改，把notifyMethod()方法中的notify()改成notifyAll()，然后再新建Run2.java类。

public class Run2 {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        for (int i = 0; i < 10; i++) {
            ThreadA t1 = new ThreadA(service);
            t1.start();
        }
        Thread.sleep(1000);
        ThreadB t2 = new ThreadB(service);
        t2.start();
    }
}

        通过运行结果看到，唤醒的顺序是调用wait()方法的倒序。 

geminigoth
关注
  • 33
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Object类wait及notify方法原理实例解析
08-24
主要介绍了Object类wait及notify方法原理实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java notify唤醒原理_Java wait和notify虚假唤醒原理
weixin_39718890的博客
02-19 117
自己在此记录一下，方便日后复习。虚假唤醒的概念jdk官方文档解释：所以说在wait和notify一块使用时，如果使用if作为条件时，会有虚假唤醒的情况发生，所以必须使用while作为循环条件。下面来举例实验：首先，创建一个资源类：(在多线程中，一般都是资源类和线程操作解耦，不放在用同一个类中，只有在线程操作资源类时，才会创建资源类的对象)package com.test;/*** 资源类* @au...
java notify唤醒原理_Java 多线程等待唤醒机制
weixin_36294922的博客
02-24 511
介绍多个线程在处理同一个资源，但是处理的动作(线程的任务)却不相同。通过等待唤醒机制可以使各个线程能有效的利用资源。等待唤醒机制所涉及到的方法：wait()：等待，将正在执行的线程释放其执行资格和执行权，并存储到线程池中。notify()：唤醒，唤醒线程池中被wait()的线程，一次唤醒一个，而且是任意的。notifyAll()：唤醒全部，可以将线程池中的所有wait()线程都唤醒。实现利用锁和等...
Java的notify()
weixin_63490470的博客
12-30 1373
Java中的notify()是一个用于线程间通信的方法，属于Object类的一部分。当多个线程间需要协调执行顺序或者资源共享时，notify()可以用来唤醒正在等待对象监视器（monitor）的某一个线程。在Java中，任何对象都可以作为同步锁，这是因为每个对象都有一个与之关联的监视器。当一个线程进入一个synchronized同步块或方法时，它会自动获取这个对象的监视器锁。如果另一个线程试图进入由同一锁保护的另一个synchronized同步块或方法，那么它将会阻塞，直到锁被释放。
java中wait/notify机制
叶落伤城的专栏
08-08 1294
通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务 后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。 以上逻辑
Java多线程线程间的通信—wait及notify方法
欢迎朋友，我是一名十多年开发经验的新手，希望多多指教。
08-15 176
线程调用wait()方法，释放它对锁的拥有权，然后等待另外的线程来通知它（通知的方式是notify()或者notifyAll()方法），这样它才能重新获得锁的拥有权和恢复执行。比如，一个可能的情况是，一个增加线程执行的时候，其他三个线程都在wait，这时候第一个线程调用了notify()方法，其他线程都将被唤醒，然后执行各自的增加或减少方法。这种选择是随意的，和具体实现有关。另一个会导致线程暂停的方法：Thread.sleep()，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。
java多线程 wait和notify
mister_you的博客
04-26 424
1. 创建自定义WaitNotify类，实现Runnable接口 public class WaitNotify implements Runnable { private boolean flag; private Object object; public WaitNotify(boolean flag, Object object) { this.flag = flag; this.object = object; }
线程间的通信机制之等待唤醒（wait / notify）机制
m0_67700096的博客
12-28 550
如果一个线程从头到尾执行完也不和别的线程打交道的话，那就不会有各种安全性问题了。但是协作越来越成为社会发展的大势，一个大任务拆成若干个小任务之后，各个小任务之间可能也需要相互协作最终才能执行完整个大任务。所以各个线程在执行过程中可以相互通信，所谓通信就是指相互交换一些数据或者发送一些控制指令，比如一个线程给另一个暂停执行的线程发送一个恢复执行的指令1、一个进程中的线程与另外一个进程中的线程通信，由于两个线程只能访问自己所属进程的地址空间和资源，故等同于进程间的通信。2、同一个进程中的两个线程进行通信。
Java多线程笔记三（线程通信wait/notify/notifyAll/sleep/yield/join）
login_sonata的博客
10-02 1073
一，wait()、notify()、notifyAll()1，信号量线程间通信的一个最简单方式是在共享对象的变量里设置信号量。线程A在一个同步块里设置boolean型成员变量hasDataToProcess为true，线程B也在同步块里读取hasDataToProcess这个成员变量。下面的例子使用了一个持有信号的对象，并提供了set和check方法:public class MySignal{
线程间通信——等待（wait)和通知（notify）
qq_44891295的博客
04-10 742
文章目录1：等待（wait)和通知（notify）的介绍2：等待（wait)和通知（notify）的执行机制 1：等待（wait)和通知（notify）的介绍 JDK提供了两个非常重要的接口线程：等待wait()方法和通知notify()方法。这两个方法在Object类中，意味着任何对象都可以调用这两个方法。方法签名如下 public final void wait() throws InterruptedException { public final native void notify(); 当在一
消息中间件-Notify的概念和原理
06-10
消息中间件-Notify的概念和原理 消息中间件-Notify的概念和原理 消息中间件-Notify的概念和原理
Java多线程基础——Lock类
08-31
Condition是Lock接口的一个方法，它提供了一种线程间通信的方式，类似于`synchronized`的wait()和notify()。每个Lock实例可以有多个Condition实例，每个Condition代表了一个单独的等待队列。线程可以调用`await()`...
JUC代码演示 Java多线程并发
05-03
Java中线程间通信的主要方式有：`wait()`、`notify()`和`notifyAll()`等方法。 虽然示例代码中未明确给出线程间通信的具体实现，但在实际开发中，我们可以通过这些方法实现线程之间的同步。例如，在等待某些条件...
Java多线程wait/notify原理
LIUZEYU12A
01-30 924
1. 引入wait/notify 回顾：在之前的学习中，当我们创建一个对象后，synchronized给对象上锁，JVM会给对象头关联一个Monitor对象，这个Monitor由三部分组成。 一是Owner对象，里面存储的是创建该对象的线程 二是EntryList，想试图获取该对象资源的其它堵塞线程队列 三是WaitSet，存储的是放弃对象锁的线程 Owner线程中的锁对象，如果发现条件不满足，调用wait()方法，既可以进入到WaitSet变为WAITING状态 EntryList下和WaitSet下
java中的notify_java中wait/notify机制
weixin_32002013的博客
02-12 138
通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务 后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。以上逻辑简单...
Java的notify机制_实例深入理解Java wait/notify执行机制
weixin_34868242的博客
03-02 317
Java wait/notifywait 使得获取到同步锁的线程在调用wait方法的时候暂停执行，让出cpu的时间片notify 通知获取同步锁的线程在获取到cpu的时间片后继续执行代码案例分析：public class MyClass {public static void main(String[] args) {//同步对象Object lock = new Object();Thread1...
Java多线程：waitnotify原理剖析
大数据开发、JAVA开发、人工智能AI
11-30 458
Java多线程wait/notify原理
JAVA系列：wait和notify的工作原理
NIO4444
09-05 1225
调用wait方法，首先会获取监视器锁，获得成功以后，会让当前线程进入等待状态进入等待队列并且释放锁； 然后 当其他线程调用notify或者notifyall以后，会选择从等待队列中唤醒任意一个线程，而执行完notify方法以后，并不会立马唤醒线程，原因是当前的线程仍然持有这把锁，处于等待状态的线程无法获得锁。必须要等到当前的线程执行完按monitorexit指令以后，也就是锁被释放以后，处于等待队列中的线程就可以开始竞争锁了。 ...
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 1990
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
Java多线程基础教程：从入门到实践
"这是一份关于Java多线程入门的学习资料，旨在帮助初学者理解并掌握Java多线程的基本概念和使用方法。文档介绍了多线程的背景知识、基础概念，包括进程与线程的区别，以及线程间的交互机制。同时，它还涵盖了Java中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

geminigoth

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值