wait() 和notify() 怎么使用 6个demo诠释它+3个demoZH

最新推荐文章于 2021-06-26 11:13:54 发布
最新推荐文章于 2021-06-26 11:13:54 发布
阅读量529 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29499107/article/details/79983140
版权

java面试题网站：www.javaoffers.com

demo1:

package com.jvm.others.thread;
/**测试Wait和notify的搭配使用
 * @author pc
 *
 */
public class WaitAndNotify {
public static void main(String[] args) throws Exception {
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("THread1开始Waiting");
   try {
    synchronized (this) {//thread1对象
    wait();
}
System.out.println("THread1结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});

        Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread2开始调用notify");
synchronized (this) {//thread2对象
notify();
}

}
});

        thread1.start();
        Thread.sleep(2000);
        thread2.start();
        //运行的结果是：
        //THread1开始Waiting
        //thread2开始调用notify
}
}

demo2:

package com.jvm.others.thread;
public class WaitAndNotify2 {
public static void main(String[] args) throws Exception {
     
Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("THread1开始Waiting");
   try {
    synchronized (this) {//thread1对象
    wait();
}

System.out.println("THread1结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});

        Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread2开始调用notify");
synchronized (this) {//thread2对象
notifyAll();
}

}
});

        thread1.start();
        Thread.sleep(2000);
        thread2.start();
      //运行的结果是：
      //THread1开始Waiting
      //thread2开始调用notify
}
}

demo3:

package com.jvm.others.thread;
public class WaitAndNotify3 {

public static void main(String[] args) throws Exception {

   final WaitAndNotify3 waitAndNotify3 = new WaitAndNotify3();  //创建一个waitAndNotify3对象，让Thread1和Thread2的同步代码块都拥有同一个 waitAndNotify3对象
   
Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("THread1开始Waiting");
   try {
    synchronized (waitAndNotify3) {//waitAndNotify3对象
    wait();
}

System.out.println("THread1结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});

        Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread2开始调用notify");
synchronized (waitAndNotify3) {//waitAndNotify3对象
notifyAll();
}

}
});

        thread1.start();
        Thread.sleep(2000);
        thread2.start();
      //运行的结果是：
        /**
       * THread1开始Waiting
java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:503)
at com.jvm.others.thread.WaitAndNotify3$1.run(WaitAndNotify3.java:16)
at java.lang.Thread.run(Thread.java:745)
thread2开始调用notify
Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
at java.lang.Object.notifyAll(Native Method)
at com.jvm.others.thread.WaitAndNotify3$2.run(WaitAndNotify3.java:33)
at java.lang.Thread.run(Thread.java:745)
       */
}
}

demo4:

package com.jvm.others.thread;


public class WaitAndNotify4 {
static final WaitAndNotify4 waitAndNotify3 = new WaitAndNotify4();  //创建一个waitAndNotify3对象，让Thread1和Thread2的同步代码块都拥有同一个 waitAndNotify3对象
public static void main(String[] args) throws Exception {

  
   
Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("THread1开始Waiting");
   try {
    synchronized (waitAndNotify3) {//thread1对象
    waitAndNotify3.wait();
}

System.out.println("THread1结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});

        Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread2开始调用notify");
synchronized (waitAndNotify3) {//thread2对象
waitAndNotify3.notify();//waitAndNotify3.notify();

}
 
}
});

        thread1.start();
        Thread.sleep(2000);
        thread2.start();
      //运行的结果是：
     /**
      * THread1开始Waiting
        thread2开始调用notify
        THread1结束Waiting
      */
}

}

demo5:

package com.jvm.others.thread;


public class WaitAndNotify5 {
static final WaitAndNotify5 waitAndNotify3 = new WaitAndNotify5();  //创建一个waitAndNotify3对象，让Thread1和Thread2的同步代码块都拥有同一个 waitAndNotify3对象
public static void main(String[] args) throws Exception {

  
   
Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("THread1开始Waiting");
   try {
    synchronized (waitAndNotify3) {//thread1对象
    waitAndNotify3.wait();
}

System.out.println("THread1结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});

        Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread2开始调用notify");
synchronized (waitAndNotify3) {//thread2对象
waitAndNotify3.notify();//waitAndNotify3.notify();

}
 
}
});

       Thread thread3 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread3开始调用Waiting");
synchronized (waitAndNotify3) {//thread2对象
try {
waitAndNotify3.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//waitAndNotify3.notify();
System.out.println("THread3结束Waiting");
}
 
} 
});
        
        thread1.start();
        thread3.start();
        
        Thread.sleep(2000);
        thread2.start();
      //运行的结果是：
     /**
       * thread3开始调用Waiting
         THread1开始Waiting
         thread2开始调用notify
         THread3结束Waiting
      */
}

}

demo6:

package com.jvm.others.thread;


public class WaitAndNotify6 {
static final WaitAndNotify6 waitAndNotify3 = new WaitAndNotify6();  //创建一个waitAndNotify3对象，让Thread1和Thread2的同步代码块都拥有同一个 waitAndNotify3对象
public static void main(String[] args) throws Exception {

  
   
Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {

Thread thread1Inner = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread1Inner开始Waiting");

   try {
    synchronized (waitAndNotify3) {//thread1对象
    waitAndNotify3.wait();
}

System.out.println("thread1Inner结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
thread1Inner.start();
System.out.println("THread1开始Waiting");
   try {
    synchronized (waitAndNotify3) {//thread1对象
    waitAndNotify3.wait();
}

System.out.println("THread1结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});

        Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread2开始调用notifyAll");
synchronized (waitAndNotify3) {//thread2对象
waitAndNotify3.notifyAll();//waitAndNotify3.notify(); 
 
}
 
}
});

       Thread thread3 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("thread3开始调用Waiting");
synchronized (waitAndNotify3) {//thread3对象
try {
waitAndNotify3.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//waitAndNotify3.notify();
System.out.println("THread3结束Waiting");
}
 
} 
});
        thread1.start();//线程一启动后线程一内部再启动和线程一一样的逻辑
        thread3.start();
        
        Thread.sleep(2000);
        thread2.start();
      //运行的结果是：
     /**
       * thread3开始调用Waiting
         THread1开始Waiting
         thread1Inner开始Waiting
         thread2开始调用notifyAll
         thread1Inner结束Waiting
         THread3结束Waiting
         THread1结束Waiting
      */
}
}

demoZH01:

package com.jvm.others.thread;


public class WaitAndNotifyZH {

public static void main(String[] args) throws Exception {
   
Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("THread1开始Waiting");
   try {
    synchronized (StaticObject.obj) {//thread1对象
    StaticObject.obj.wait();
}

System.out.println("THread1结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
        thread1.start();
}

}

demoZH02:

package com.jvm.others.thread;


public class WaitAndNotifyZH2 {

public static void main(String[] args) throws Exception {

  
   
Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
System.out.println("THread1开始Waiting");
   try {
    synchronized (StaticObject.obj) {//thread1对象
    StaticObject.obj.wait();
}

System.out.println("THread1结束Waiting");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
        thread2.start();
}

}

demoZH03:

package com.jvm.others.thread;


public class WaitAndNotifyZH3 {

public static void main(String[] args) throws Exception {

  
   
Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {
 
   try {
    synchronized (StaticObject.obj) {//thread1对象
    StaticObject.obj.notifyAll();
}
System.out.println("调用了notifyAll");

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
        thread1.start();
      
       
      //运行的结果是：

           //demoZH01线程没有结束

           //demoZH02线程也没有结束

}
}

总结：

wait() 和notify() 或者 notifyAll() 进行搭配的时候必须在synchronized（obj）模块里  (注：这里的obj为任意一对象)，

切调用wait() notify()，notifyAll()的对象要同一（注：为相同的对象。）

wait() notify()，notifyAll()这三个方法的作用范围：必须在同一个main方法里，否者无效。（请看demoZH01，demoZH02，demoZH02）.

调用notify()时：恢复第一个调用wait（）方法的线程，其他的线程不恢复。（注：每个调用wait()方法的对象要同一，即都是相同的一个对象。调用notify()方法的对象  和  调用wait()方法的对象    要一样）

调用notifyAll()时：恢复所有调用wait()方法的线程。（注：每个调用wait()方法的对象要同一，即都是相同的一个对象。调用notifyAll()方法的对象  和  调用wait()方法的对象    要一样） 

调用wait方法时：会释放当前的锁对象并加入该对象的等待池中。只有针对此对象调用notify()或者notifyAll()方法后本线程才进入对象锁池准备竞争对象锁 当锁池中的线程获得锁后，才开始准备恢复执行操作（这也是必须在synchronized（obj）模块里的原因，当线程唤醒后已经获得了对象锁，并且此时的线程处于synchronized（obj）模块里，假如线程没有在synchronized（obj）模块里，那锁对象所对应的线程进入到锁池中并获得锁 就没有意义了。同时java语言规定 wait() notify()，notifyAll()要在 在synchronized（obj）模块里使用，否者会报错的）。在java中，每个对象都有两个池，锁(monitor)池和等待池。

3：注意： 线程的等待与唤醒都与所关联的对象有关， 因为他们依赖 关联对象的两个池，锁(monitor)池和等待池。

学习笔记cmj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何在Java中正确使用 wait, notify 和 notifyAll
12-22
wait， notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。 　在 Java 中可以用 wait、notify 和 notifyAll 来实现...
Java多线程wait()、notify() 线程通信的小demo
weixin_43566803的博客
03-10 288
public class 等待唤醒 { public static void main(String[] args) { Object lock = new Object(); new Thread(new Runnable() { @Override public void run() { try { //等待顾客说要买什么东西
JavaDemo——线程协作wait、notify、notifyAll
FlyLikeButterfly的博客
08-20 264
wait()、notify()、notifyAll()是Object对象的final方法。 必须在拿到锁的情况下使用（同步块中）。 wait()，立即释放锁并进入阻塞。 notify()，只是唤醒一个阻塞线程（如果有多个wait则随机一个）并不立即释放锁，待notify()同步块运行完释放锁，唤醒的线程才可以重新获得锁。 notifyAll()，唤醒所有阻塞线程并不立即释放锁，唤醒的线程由...
java Object类wait和notify Demo
weixin_30376509的博客
08-10 177
import java.util.logging.Level; import java.util.logging.Logger; class Task extends Thread { @Override public void run() { try { synchronized (this) { Thread t = Thread.cu...
线程通信之wait() 和notify() 方法
ccuaman的博客
07-10 2114
线程通信之wait() 和notify() 方法 通信方法 wait():调用wait方法的线程，当前持有锁的该线程等待，直至该对象的另一个持锁线程调用notify/notifyAll操作。 wait(long timeOut)、wait(long timeOut,int nanos) notify():通知持有该对象锁的所有线程中的的随意一个线程被唤醒 notifyAll():通知持有该对象锁的所有线程被同时唤醒 线程通信的方法：wait\notify\notifyAll操作都是属于Object类提供的方
JAVA多线程之wait和notify的使用小案例，记录一下
wjy_0208的博客
06-26 247
1.代码 package com.example.test.demo.thread; import java.util.Date; /** * @author 王健宇 * @title: WaitNotifyDemo * @description * @date 2021/6/26 10:41 */ public class WaitNotifyDemo { // 消费产品 class User { String name; //姓名 Str
wait_notify_demo
01-10
使用Java多线程的wait和notify方法实现最简单的生产者消费者模式
wait和notify讲解
08-30
wait和notify讲解
Java多线程中wait、notify、notifyAll使用详解
08-26
主要介绍了Java多线程中wait、notify、notifyAll使用详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详细分析java线程wait和notify
09-03
本篇文章是对java多线程wait()和notify()进行了详细的分析介绍，需要了解的朋友参考下
Java消费者生产者|线程等待线程唤醒WaitNotifyDemo
12-13
Java写的消费者生产者模式，主要用到线程同步、线程等待和线程唤醒
java中几个notify、wait使用实例
08-27
java中多线程编程notify、wait的使用
线程wait和notify方法的demo详解
weixin_30877181的博客
12-06 225
wait和notify都是针对某个线程而言的： package com.roocon.thread.t1; public class NewThread implements Runnable { @Override public void run() { while(true){ try { ...
理解 JAVA线程同步及其中中wait()和notify()简洁例子
fei_ing的专栏
04-23 724
JAVA线程同步中wait()和notify()简洁例子   搞懂这两个的用法之前，请你务必搞懂线程同步的道理，否则，下面这一大篇你应该是看不懂的。 wait()和notify()一系列的方法，是属于对象的，不是属于线程的。它们用在线程同步时，synchronized语句块中。 我们都知道，在synchronized语句块中，同一个对象，一个线程在执行完这一块代码之前，另一个线程，如果传进来
java线程 wait notify_详细分析java线程wait和notify
weixin_34008445的博客
02-12 144
wait()和notify()是直接隶属于Object类，也就是说，所有对象都拥有这一对方法。初看起来这十分 不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。而调用任意对象的notify()方法则导致因调用该对象的wait() 方法而阻塞的线程中随机选择的一个解除阻塞(但要等到获得...
线程通讯两个Demo，wait()notify()与park()unpark()
weixin_39276203的博客
03-04 146
实现目标：两个线程，线程1向list集合装入对象，装入到第5个元素时，线程2输出一句话，再次回到线程1，直到装入10个元素。 1.使用wait(),notify() （1）首先启动线程2，进入同步代码块，判断list的元素数量，如果不为5，调用wait方法，让出同步锁。 （2）线程1拿到锁，顺序向list集合中放入元素，当集合元素数量达到5时，调用notify方法，调用wait方法(如果不调用wait方法，无法释放锁，将会执行到循环结束) （3）线程2向下执行，输出一句话，调用notify方法 （4）线程1
一个理解wait()与notify()的例子
xm4014的专栏
01-28 1万+
下面是我原来在CSDN论坛上看到的一个贴子，涉及到同步,wait(),notify()等概念的理解，我试着根据原来的一些回复和Think in Java上的相关概念将wait()和notify()这两个方法剖析了一下，欢迎指教.问题如下：file://分析这段程序，并解释一下，着重讲讲synchronized、wait(),notify 谢谢！class ThreadA {  public
ASM读取class字节码获取类的注解信息
热门推荐
qq_29499107的博客
05-22 2万+
spring中底层运用到了asm技术，这种技术是不创建Class类对象直接读取class 文件就可以获取Class的信息。那么我们在公司很有可能都会开发自己公司的一套框架，通常来说，就是把现在流行的技术二次开发封装，方便自己公司开发项目，二次开发时很有可能你会自己设计一些注解，这些注解是做什么用的，用在什么地方，比如类上面或者属性或者方法等等，此时你很有可能就会用到ASM技术，在不初始化Class...
＜init＞构造器 与构造方法的关系
qq_29499107的博客
06-28 2万+
java中的构造器有两种:分别是 实例构造器<init>和类构造器<cinit> . 构造器的作用: 构造器的产生过程实际上是一个**代码收敛的过程**，**编译器会把语句块**（对于实例构造器而言是“{}”块，对于类构造器而言是“static{}”块）、**变量初始化**（实例变量和类变量）、**调用父类的实例构造器**（仅仅是实例构造器，＜clinit＞（）方法中无须调用父类的＜clinit＞（）方法，虚拟机会自动保证父类构造器的执行，但在＜clinit＞（）方法中经常会生成调用java.lang.
java中wait和notify使用
最新发布
03-16
Java中的wait和notify是线程同步的机制，用于实现线程之间的通信和协作。 wait方法是Object类中的方法，用于使线程进入等待状态，直到其他线程调用notify或notifyAll方法唤醒它。wait方法必须在同步块中调用，否则...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值