wait与notify

最新推荐文章于 2023-06-22 22:32:18 发布
最新推荐文章于 2023-06-22 22:32:18 发布
阅读量174 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuiziyoudexiao/article/details/119711333
版权

为什么需要wait方法

  • 一个线程调用sleep方法会陷入休眠状态，虽然释放了cpu但是不会释放锁，这样就会造成浪费，因为陷入sleep状态的线程白白占着共享资源而没有使用它，使得其他线程不得不陷入等待状态。
  • 而wait方法虽然也会使线程陷入暂停状态，与sleep不同的是它会将cpu和锁资源全部释放。
  • 如下 线程1占用锁后休眠了100秒，在线程1休眠期间，线程2无法获得锁，因此无法往下执行，这样白白浪费了cpu资源。
new Thread(() -> {
    synchronized (Code.class){
        System.out.println("t1获得锁");
        try {
            Thread.sleep(100*1000); //休眠时依然占用锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();

Thread.sleep(1000);
new Thread(()->{
    System.out.println("t2尝试获得锁");
     synchronized (Code.class){
         System.out.println("t2成功获得锁");
     }
}).start();

此时可以使用wait方法将线程1休眠，这样线程1会释放锁，就不会耽误线程2的执行。
new Thread(() -> {
    synchronized (Code.class){
        System.out.println("t1获得锁");
        try {
            Code.class.wait(100*1000); //休眠时会释放锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();

Thread.sleep(1000);
new Thread(()->{
    System.out.println("t2尝试获得锁");
     synchronized (Code.class){
         System.out.println("t2成功获得锁");
     }
}).start();

wait方法的原理

  • wait方法的底层也会使用到monitor对象，如图所示。当一个线程申请到锁之后，就会让monitor对象的owner属性指向自己，但是当它发现虽然自己得到了锁但是因为其他条件不满足，无法执行，就会调用wait方法。
  • 调用wait方法之后的线程会进入waitset队列，线程变为waiting状态。与entrylist队列线程不同的是，entrylist队列线程是申请不到锁资源而陷入等待的状态，而waitset队列线程是申请锁资源后由于其他条件不满足而必须调用wait方法重新释放锁的线程。
  • 陷入waiting状态的线程会在owner线程调用notify或notifyAll时唤醒，唤醒后的线程不会立刻获得锁，而是重新进入entrylist队列重新竞争锁。
  • 因此entrylist可以称为阻塞队列，waitset可以称为条件队列。
    在这里插入图片描述

相关API

  • obj.wait() 让获得obj对象锁的线程到waitset等待。
  • obj.notify() 在obj对象关联的monitor对象上正在waitset等待的线程中挑一个唤醒。
  • obj.notifyALL() 在obj对象关联的monitor对象上正在等待的线程全部唤醒。
  • 他们都属于object对象的方法，必须获得此对象的锁（成为owner线程后），才能调用这几个方法。

wait/notify方法的基本使用

  • wait方法必须在线程获得锁之后才能，调用，如果没有获得锁就调用wait方法会报错，即只有owner线程才有权限唤醒waitset中等待的线程。
public class Demo {
    public static final Object lock = new Object();
    public static final Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) throws InterruptedException {
           lock.wait(); //会抛出异常 IllegalMonitorStateException
    }
}
  • 如下代码才能让主线程陷入waiting状态
public class Demo {
    public static final Object lock = new Object();
    public static final Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) throws InterruptedException {
        synchronized (lock){
             lock.wait();
        }
    }
}
  • notify方法会在lock对象上面挑一个waiting线程唤醒
public class Demo {
    public static final Object lock = new Object();
    public static final Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) throws InterruptedException {
           new Thread(()->{
               log.info("线程0开始执行");
               synchronized (lock){
                   try {
                       lock.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               log.info("线程0被唤醒继续执行");
           }).start();

           new Thread(()->{
                log.info("线程1开始执行");
                synchronized (lock){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                       e.printStackTrace();
                }
                }
                log.info("线程1被唤醒继续执行");
           }).start();
           Thread.sleep(2000);
           synchronized (lock){
               log.info("主线程唤醒一个waiting状态的线程");
               lock.notify();
           }
    }
}
//2020-08-26 15:13:48.153 [Thread-0 线程] [INFO] [Test] --- 线程0开始执行
//2020-08-26 15:13:48.153 [Thread-1 线程] [INFO] [Test] --- 线程1开始执行 
//2020-08-26 15:13:50.157 [main 线程] [INFO] [Test] --- 主线程唤醒一个waiting状态的线程 
//2020-08-26 15:13:50.157 [Thread-0 线程] [INFO] [Test] --- 线程0被唤醒继续执行
  • notifyall方法会唤醒lock对象上面所有waiting线程
public class Demo {
    public static final Object lock = new Object();
    public static final Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) throws InterruptedException {
           new Thread(()->{
               log.info("线程0开始执行");
               synchronized (lock){
                   try {
                       lock.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               log.info("线程0被唤醒继续执行");
           }).start();

           new Thread(()->{
                log.info("线程1开始执行");
                synchronized (lock){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                       e.printStackTrace();
                }
                }
                log.info("线程1被唤醒继续执行");
           }).start();
           Thread.sleep(2000);
           synchronized (lock){
               log.info("主线程唤醒一个waiting状态的线程");
               lock.notifyAll();
           }
    }
}
//2020-08-26 15:17:14.926 [Thread-1 线程] [INFO] [Test] --- 线程1开始执行
//2020-08-26 15:17:14.926 [Thread-0 线程] [INFO] [Test] --- 线程0开始执行
//2020-08-26 15:17:16.925 [main 线程] [INFO] [Test] --- 主线程唤醒一个waiting状态的线程
//2020-08-26 15:17:16.925 [Thread-0 线程] [INFO] [Test] --- 线程0被唤醒继续执行
//2020-08-26 15:17:16.925 [Thread-1 线程] [INFO] [Test] --- 线程1被唤醒继续执行
  • wait方法可以加参数表示有限时的等待，比如wait(3000)会让当前线程等待三秒，如果三秒后还没有其他线程唤醒它，该线程会自动唤醒，如果三秒内它被其他线程唤醒它就不用等三秒唤醒。

一个送烟的例子

  • 小明和其他三个人要干活，他们依次在一个房间干活，该房间只能允许一个人进入。小明烟瘾很大，如果没有烟就无法干活，刚开始小明进入房间，他发现没烟就会休息5秒，而在2秒后有服务员过来送烟，到5秒的时候小明发现有烟了开始干活，干完之后其他人在依次干活。
  • 在这个例子中烟就是小明线程运行的必要条件。
public class Demo {
    public static final Object room = new Object();
    public static volatile boolean flag = false; //标记当前是否有烟
    public static final Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) throws InterruptedException {
           new Thread(()->{
               synchronized (room){
                   log.info("有烟没--"+flag);
                   if(flag==false){
                       log.info("没烟 先睡5秒");
                       try {
                           Thread.sleep(5000);
                       } catch (InterruptedException e) { e.printStackTrace(); }
                   }
                   log.info("有烟没--"+flag);
                   if(flag==true){
                       log.info("有烟了 可以开始干活了");
                   }else{
                       log.info("没干成活");
                   }
               }
           },"小明").start();
           for(int i=1;i<4;i++){
               new Thread(()->{
                   synchronized (room){
                       log.info("开始干活了");
                   }
               },"线程"+i).start();
           }

           Thread.sleep(2000);
           new Thread(()->{
               log.info("两秒后开始送烟");
               flag = true;
           },"送烟线程").start();
    }
}
//2020-08-26 16:03:53.567 [小明 线程] [INFO] [Test] --- 有烟没--false
//2020-08-26 16:03:53.570 [小明 线程] [INFO] [Test] --- 没烟 先睡5秒
//2020-08-26 16:03:55.567 [送烟线程 线程] [INFO] [Test] --- 两秒后开始送烟
//2020-08-26 16:03:58.570 [小明 线程] [INFO] [Test] --- 有烟没--true
//2020-08-26 16:03:58.570 [小明 线程] [INFO] [Test] --- 有烟了 可以开始干活了
//2020-08-26 16:03:58.570 [线程3 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:03:58.570 [线程2 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:03:58.571 [线程1 线程] [INFO] [Test] --- 开始干活了
  • 可以发现刚开始小明占着房间没有干活，直到5秒后才开始干活，那么相当于房间使用权白白浪费了5秒，而且其他人必须要等待小明干完活才能干活，这5秒房间时间使用权完全可以交给没有烟瘾的其他人用。
  • 而且需要注意，送烟线程不能加synchronized ，如果送烟线程加了synchronized ，因为小明已经占了房间，所以送烟线程进不了房间和其他干活的人一样也会阻塞。
  • 使用wait/notify来优化送烟例子
public class Demo {
    public static final Object room = new Object();
    public static boolean flag = false; //标记当前是否有烟
    public static final Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) throws InterruptedException {
           new Thread(()->{
               synchronized (room){
                   log.info("有烟没--"+flag);
                   if(flag==false){
                       log.info("没烟 先睡5秒");
                       try {
                           room.wait(5000);
                       } catch (InterruptedException e) { e.printStackTrace(); }
                   }
                   log.info("有烟没--"+flag);
                   if(flag==true){
                       log.info("有烟了 可以开始干活了");
                   }else{
                       log.info("没干成活");
                   }
               }
           },"小明").start();
           for(int i=1;i<4;i++){
               new Thread(()->{
                   synchronized (room){
                       log.info("开始干活了");
                   }
               },"线程"+i).start();
           }

           Thread.sleep(2000);
           new Thread(()->{
               synchronized (room){
                   log.info("两秒后开始送烟 并叫醒小明线程");
                   flag = true;
                   room.notify();
               }
           },"送烟线程").start();
    }
}
//2020-08-26 16:24:06.543 [小明 线程] [INFO] [Test] --- 有烟没--false
//2020-08-26 16:24:06.545 [小明 线程] [INFO] [Test] --- 没烟 先睡5秒
//2020-08-26 16:24:06.545 [线程3 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:24:06.545 [线程2 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:24:06.545 [线程1 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:24:08.544 [送烟线程 线程] [INFO] [Test] --- 两秒后开始送烟 并叫醒小明线程
//2020-08-26 16:24:08.544 [小明 线程] [INFO] [Test] --- 有烟没--true
//2020-08-26 16:24:08.544 [小明 线程] [INFO] [Test] --- 有烟了 可以开始干活了
  • 可以看到小明在发现没有烟后不会占着房间休息，而是让出房间使用权，此时后面其他人依然可以使用房间干活，当送烟线程送到烟后再去休息室将小明叫醒，小明可以继续干活。
  • 但是如果条件队列中阻塞的不止小明一个人，还有小红也在休息，那么送烟线程可能错误唤醒小红而没有把小明唤醒。如下所示，小红没有干成活，小明依然在休息室休息。这种错误唤醒的情况也称为虚假唤醒。
public class Demo {
    public static final Object room = new Object();
    public static boolean flag = false; //标记当前是否有烟
    public static boolean flag2 = false; //标记当前是否有外卖
    public static final Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            synchronized (room){
                log.info("外卖到了没--"+flag2);
                if(flag2==false){
                    log.info("没有外卖 进入休息室休息");
                    try {
                        room.wait();
                    } catch (InterruptedException e) { e.printStackTrace(); }
                }
                log.info("外卖到了没--"+flag2);
                if(flag2==true){
                    log.info("有外卖了 可以开始干活了");
                }else{
                    log.info("没干成活");
                }
            }
        },"小红").start();
           new Thread(()->{
               synchronized (room){
                   log.info("有烟没--"+flag);
                   if(flag==false){
                       log.info("没烟 进入休息室休息");
                       try {
                           room.wait();
                       } catch (InterruptedException e) { e.printStackTrace(); }
                   }
                   log.info("有烟没--"+flag);
                   if(flag==true){
                       log.info("有烟了 可以开始干活了");
                   }else{
                       log.info("没干成活");
                   }
               }
           },"小明").start();

           for(int i=1;i<4;i++){
               new Thread(()->{
                   synchronized (room){
                       log.info("开始干活了");
                   }
               },"线程"+i).start();
           }

           Thread.sleep(2000);
           new Thread(()->{
               synchronized (room){
                   log.info("两秒后开始送烟 并叫醒小明线程");
                   flag = true;
                   room.notify();
               }
           },"送烟线程").start();
    }
}
//2020-08-26 16:40:48.319 [小红 线程] [INFO] [Test] --- 外卖到了没--false
//2020-08-26 16:40:48.321 [小红 线程] [INFO] [Test] --- 没有外卖 进入休息室休息
//2020-08-26 16:40:48.321 [线程3 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:40:48.322 [线程2 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:40:48.322 [线程1 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:40:48.322 [小明 线程] [INFO] [Test] --- 有烟没--false
//2020-08-26 16:40:48.322 [小明 线程] [INFO] [Test] --- 没烟 进入休息室休息
//2020-08-26 16:40:50.319 [送烟线程 线程] [INFO] [Test] --- 两秒后开始送烟 并叫醒小明线程
//2020-08-26 16:40:50.319 [小红 线程] [INFO] [Test] --- 外卖到了没--false
//2020-08-26 16:40:50.319 [小红 线程] [INFO] [Test] --- 没干成活
  • 这时候送烟线程就不能使用notify随机唤醒一个线程，而应该使用notifyall将休息室线程全部唤醒，此时小明小红都被唤醒，小明看到有烟了开始干活，小红发现没有外卖不会干活。
new Thread(()->{
    synchronized (room){
        log.info("两秒后开始送烟 并叫醒所有线程");
        flag = true;
        room.notifyAll();
    }
},"送烟线程").start();
  • 但是此时还有一个问题，小红被送烟线程唤醒了却没有干成活，等送外卖线程来了小红已经不在休息室了，小红就永远不会干活了，此时需要进行改进，当小红被叫醒后发现外卖并没有送到，她应该再次进入休息室等待，直到外卖真的送到了。
public class Demo {
    public static final Object room = new Object();
    public static boolean flag = false; //标记当前是否有烟
    public static boolean flag2 = false; //标记当前是否有外卖
    public static final Logger log = LoggerFactory.getLogger(Test.class);
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            synchronized (room){
                while(flag2==false){
                    log.info("外卖到了没--"+flag2);
                    log.info("没有外卖 进入休息室休息");
                    try {
                        room.wait();
                    } catch (InterruptedException e) { e.printStackTrace(); }
                }
                if(flag2==true){
                    log.info("外卖到了 可以干活了");
                }
            }
        },"小红").start();
           new Thread(()->{
               synchronized (room){
                   while(flag==false){
                       log.info("有烟没--"+flag);
                       log.info("没烟 进入休息室休息");
                       try {
                           room.wait();
                       } catch (InterruptedException e) { e.printStackTrace(); }
                   }
                   if(flag==true){
                       log.info("烟到了 可以干活了");
                   }
               }
           },"小明").start();

           for(int i=1;i<4;i++){
               new Thread(()->{
                   synchronized (room){
                       log.info("开始干活了");
                   }
               },"线程"+i).start();
           }

           Thread.sleep(2000);
           new Thread(()->{
               synchronized (room){
                   log.info("两秒后开始送烟 并叫醒所有线程");
                   flag = true;
                   room.notifyAll();
               }
           },"送烟线程").start();
    }
}
//2020-08-26 16:57:57.948 [小红 线程] [INFO] [Test] --- 外卖到了没--false
//2020-08-26 16:57:57.951 [小红 线程] [INFO] [Test] --- 没有外卖 进入休息室休息
//2020-08-26 16:57:57.951 [线程2 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:57:57.951 [线程3 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:57:57.951 [线程1 线程] [INFO] [Test] --- 开始干活了
//2020-08-26 16:57:57.951 [小明 线程] [INFO] [Test] --- 有烟没--false
//2020-08-26 16:57:57.951 [小明 线程] [INFO] [Test] --- 没烟 进入休息室休息
//2020-08-26 16:57:59.950 [送烟线程 线程] [INFO] [Test] --- 两秒后开始送烟 并叫醒所有线程
//2020-08-26 16:57:59.950 [小明 线程] [INFO] [Test] --- 烟到了 可以干活了
//2020-08-26 16:57:59.950 [小红 线程] [INFO] [Test] --- 外卖到了没--false
//2020-08-26 16:57:59.951 [小红 线程] [INFO] [Test] --- 没有外卖 进入休息室休息
  • 另外可以使用ReentrantLock设置多个条件队列，彻底解决错误唤醒的问题。
zuiziyoudexiao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
wait方法 与 notify方法
weixin_43808717的博客
03-31 1万+
1. 线程状态图 这是线程的7状态模型图，常见的7大状态之间的转换关系也在上面。多线程之间的通信主要用到4个方法，wait（）、wait（long time）、notify（）、notifyAll（），其他方法在多线程基础中都有介绍。 wait（）：作用是使当前线程从调用处中断并且释放锁转入等待队列，直到收到notify或者notifyAll的通知才能从等待队列转入锁池队列，没有收到停止会一直死等。 wait（long time）：相比wait多了一个等待的时间time，如果经过time(毫秒)时
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方法详解
我的主页
05-18 3545
本期讲解：Java 多线程中的 wait方法、notify方法、notifyAll方法，wait方法与sleep方法之间的区别。
【Java|多线程与高并发】wait和notify方法详解
最新发布
云泽野の编程日记
06-22 1524
在Java多线程环境中,线程之间是抢占式执行的,线程的调度是随机的.这就很难受了. 在很多情况下我们希望线程以我们想要的顺序来执行. 这就需要wait和notify这两个方法wait和notify方法用于实现线程间的协作和通信.wait方法使线程进入等待状态，notify方法唤醒一个等待线程，notifyAll方法唤醒所有等待线程。通过上述三个方法，可以使线程按照特定的顺序执行或者等待某个条件满足后再执行。希望这篇文章能帮到你!专栏:《从零开始的Java学习之旅》在不断更新中,欢迎订阅!
Java多线程中的 wait() 和 notify() 方法
sinat_31583645的博客
03-17 2605
多线程并发的场景下，有时需要某些线程先执行，这些线程执行结束后其他线程再继续执行, wait()和notify()是Object类的方法，用于线程的等待与唤醒，必须搭配synchronized 锁来使用。
主线程去控制子线程wait与notify
05-04
在Java多线程编程中，`wait()`和`notify()`是两个非常重要的方法，它们用于线程间的协作和通信。这两个方法是Java语言中的Object类提供的，因此所有的对象都可以使用。在本文中，我们将深入探讨如何使用主线程来控制...
wait和notify讲解
08-30
wait和notify讲解
浅谈java多线程wait，notify
08-25
_java多线程wait、notify机制详解_ 在Java多线程编程中，wait和notify是两个非常重要的机制，用于实现线程之间的通信和同步。在本文中，我们将通过示例代码详细介绍Java多线程wait和notify的使用，帮助读者更好地...
Java多线程中wait、notify、notifyAll使用详解
08-26
Java多线程中wait、notify、notifyAll使用详解 Java中多线程编程中，wait、notify、notifyAll三个方法是非常重要的，它们都是Object对象的方法，用于线程之间的通信。下面我们将详细介绍这三个方法的使用和作用。 ...
详解Java程序并发的Wait-Notify机制
09-03
Java程序并发的Wait-Notify机制是Java多线程编程中的一种重要同步工具，它允许线程之间通过共享对象进行通信和协作。这个机制基于Java的内置锁（也称为监视器锁），通常与`synchronized`关键字一起使用。在Java中，`...
为什么wait和notify方法要在同步块中调用？
m0_56020102的博客
11-24 1022
调用 notify()或notifyAll()方法的原因通常是，调用线程希望告诉其他等待中的线程:"特殊状态已经被设 置"。wait()方法强制当前线程释放对象锁。在调用对象的notify()和notifyAll()方法之前，调用线程必须已经得到该对象的锁。因此，必须在某 个对象的同步方法或同步代码块中才能调用该对象的notify()或notifyAll()方法。1. 只有在调用线程拥有某个对象的独占锁时，才能够调用该对象的wait(),notify()和notifyAll()方 法。
多线程_wait()和notify()详解
chuige2013的博客
04-05 936
wait()和notify()方法调用的前提是，二者所在的线程体中（即run()方法体）都需要先通过synchronized获取对象的锁；当waitThread线程调用wait()方法后，会释放锁对象，线程由RUNNING状态转向WAITING状态，即该线程进入等待队列中；wait(）方法释放锁对象之前，notifyThread线程会阻塞在synchronzied获取锁对象的位置；
Object类的常见方法总结
大梁学编程
04-07 383
Object类是一个特殊的类，是所有类的父类。它主要提供了以下11个方法： public final native Class<?> getClass();//用于返回当前运行时对象的Class对象 public native int hashCode();//用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的HashMap。 public boolean...
线程等待与唤醒
一名在校大三学习JAVA
06-28 1937
目录概念等待方法 唤醒方法 唤醒和阻塞具体的使用 wait和sleep的区别
wait和notify方法详解
qq_42261668的博客
11-06 2622
wait() 使当前线程等待，直到另一个线程为此对象调用notify（）方法或notifyAll（）方法。换句话说，这个方法的行为就像它只是执行wait（0）一样（如果没有当前对象notify（）唤醒就会一直等待）。 1.当前线程必须拥有此对象的monitor监视器（锁）。2.当前线程调用wait（）方法，线程就会释放此锁的所有权，并等待，3.直到另一个线程通过调用notify方法或notifyAll方法通知在该对象的监视器（锁）上等待的线程唤醒。4.然后线程等待，直到它可以重新获得监视器（锁）的所有权然
java——wait和notify的基本用法
xhhhx_的博客
04-14 1万+
wait的用法以及它的3种结束条件：1.notify2.interrupted3.时间超时
并发编程学习之wait()和notify()
【欢迎关注公众号：冬瓜白】
08-31 2626
wait()和notify()方法主要是用来支持多线程之间的协作。但是这两个方法均为Object的方法，也就是说任何对象都可以调用这两个方法。 比如在线程A中，一个对象实例object调用了wait()方法后，当前线程A就会进入object对象的等待队列（这个等待队列中可能会有多个线程），会停止继续执行，进入等待状态，直到其他线程调用了object.notify()方法后，线程A才有可能继续...
Java多线程之wait(),notify(),notifyAll()
热门推荐
溺水的鱼 - Later equals never.
10-11 5万+
在多线程的情况下，由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。    wait与notify是java同步机制中重要的组成部分。结合与synchronized关键字使用，可以建立很多优秀的同步模型。   synchronized(this){ }等价于publi
wait和notify。
孤芳不自赏
05-17 881
wait       方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入”预执行队列“中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前线程释放锁。在从wait()返回前，线程...
java实现wait与notify的工具
03-20
Java中的wait()和notify()是用于线程间通信的工具，可以实现线程的同步和协作。wait()方法会使当前线程进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它；而notify()方法则会随机唤醒一个正在等待的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值