java多线程基础总结【四】虚假唤醒

最新推荐文章于 2023-10-21 21:00:59 发布
最新推荐文章于 2023-10-21 21:00:59 发布
阅读量3.8k 收藏 5
点赞数 1
分类专栏： Java 文章标签： java 多线程 虚假唤醒
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15784927/article/details/79809615
版权
我们先来看一组例子 
package com.buerc.thread;

public class TesProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk=new Clerk();
		
		Producer producer=new Producer(clerk);
		Consumer consumer=new Consumer(clerk);
		
		new Thread(producer,"生产者A1").start();
		new Thread(consumer,"消费者B1").start();
	}
}

class Clerk{//店员类
	private static final int TOTAL=1;//数字取1是为了放大问题
	private int num=0;
	
	public synchronized void get() {//店员买货
		if(num>=TOTAL) {
			System.out.println("库存已满，无法进货");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}else {
			System.out.println(Thread.currentThread().getName()+" : "+ (num++));
			this.notifyAll();
		}
	}
	
	public synchronized void sale() {//店员卖货
		if(num<=0) {
			System.out.println("库存已空，无法卖货");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}else {
			System.out.println(Thread.currentThread().getName()+" : "+(num--));
			this.notifyAll();
		}
	}
}

class Producer implements Runnable{
	private Clerk clerk;
	
	public Producer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			try {
				Thread.sleep(200);//放大问题
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
}

class Consumer implements Runnable{
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			clerk.sale();
		}
	}
}
这样看起来似乎很合理。一个生产者生产，一个消费者消费，但是运行起来却是控制台没停。而我们这里是for20次循环，按理来说程序最终会终止，可情况恰恰相反。问题产生的根源是，由于生产者现象睡眠了200毫秒，因而可能产生的情况是最后消费者线程循环走完了然后就真的结束了，而生产者线程由于wait没有线程来唤醒，所以最终导致一直等待，因而程序不会结束，控制台就不终止。解决方法： 
package com.buerc.thread;

public class TesProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk=new Clerk();
		
		Producer producer=new Producer(clerk);
		Consumer consumer=new Consumer(clerk);
		
		new Thread(producer,"生产者A1").start();
		new Thread(consumer,"消费者B1").start();
	}
}

class Clerk{//店员类
	private static final int TOTAL=1;//数字取1是为了放大问题
	private int num=0;
	
	public synchronized void get() {//店员买货
		if(num>=TOTAL) {
			System.out.println("库存已满，无法进货");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+ (num++));
		this.notifyAll();
	}
	
	public synchronized void sale() {//店员卖货
		if(num<=0) {
			System.out.println("库存已空，无法卖货");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+(num--));
		this.notifyAll();
		
	}
}

class Producer implements Runnable{
	private Clerk clerk;
	
	public Producer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			try {
				Thread.sleep(200);//放大问题
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
}

class Consumer implements Runnable{
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			clerk.sale();
		}
	}
}

这里把同步方法的else去掉了，那么无论最终哪个线程先走完，都会执行wait后面的方法，即它在结束前会唤醒等待的线程，因而这个线程最终也会完整的执行完，最后程序终止。这种方法的确解决了程序无法终止的问题，但是我们来看看，当我们多加一对消费者线程和生产者线程时。

package com.buerc.thread;

public class TesProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk=new Clerk();
		
		Producer producer=new Producer(clerk);
		Consumer consumer=new Consumer(clerk);
		Producer producer2=new Producer(clerk);
		Consumer consumer2=new Consumer(clerk);
		
		new Thread(producer,"生产者A1").start();
		new Thread(consumer,"消费者B1").start();
		new Thread(producer2,"生产者A2").start();
		new Thread(consumer2,"消费者B2").start();
	}
}

class Clerk{//店员类
	private static final int TOTAL=1;//数字取1是为了放大问题
	private int num=0;
	
	public synchronized void get() {//店员买货
		if(num>=TOTAL) {
			System.out.println("库存已满，无法进货");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+ (num++));
		this.notifyAll();
	}
	
	public synchronized void sale() {//店员卖货
		if(num<=0) {
			System.out.println("库存已空，无法卖货");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+(num--));
		this.notifyAll();
		
	}
}

class Producer implements Runnable{
	private Clerk clerk;
	
	public Producer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			try {
				Thread.sleep(200);//放大问题
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
}

class Consumer implements Runnable{
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			clerk.sale();
		}
	}
}
这种情况出现了产品数为负的情况，肯定不合适。这就是虚假唤醒，因为有可能num==0，然后两个消费者线程都wait,此时生产者执行num++后，在唤醒却是唤醒了所有等待的线程，此时这两个消费者线程抢占资源后立马执行wait之后的操作，即num--就会出现产品为负的情况。为了避免这种情况我们应该让wait（）在while循环中。（API上关于虚假唤醒的解决方式） 
package com.buerc.thread;

public class TesProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk=new Clerk();
		
		Producer producer=new Producer(clerk);
		Consumer consumer=new Consumer(clerk);
		Producer producer2=new Producer(clerk);
		Consumer consumer2=new Consumer(clerk);
		
		new Thread(producer,"生产者A1").start();
		new Thread(consumer,"消费者B1").start();
		new Thread(producer2,"生产者A2").start();
		new Thread(consumer2,"消费者B2").start();
	}
}

class Clerk{//店员类
	private static final int TOTAL=1;//数字取1是为了放大问题
	private int num=0;
	
	public synchronized void get() {//店员买货
		while(num>=TOTAL) {
			System.out.println("库存已满，无法进货");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+ (num++));
		this.notifyAll();
	}
	
	public synchronized void sale() {//店员卖货
		while(num<=0) {
			System.out.println("库存已空，无法卖货");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+(num--));
		this.notifyAll();
		
	}
}

class Producer implements Runnable{
	private Clerk clerk;
	
	public Producer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			try {
				Thread.sleep(200);//放大问题
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
}

class Consumer implements Runnable{
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			clerk.sale();
		}
	}
}

buerc
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Java 多线程 唤醒中的 虚假唤醒
norang的博客
10-30 235
这里写目录标题synchronized 版本，双线程，生产者消费者运行结果synchronized 版本，四线程， 生产者消费者运行结果这里，居然，卡住了，不知道为啥synchronized 版本，四线程， 生产者消费者，使用 while 判断运行结果总结参考目录 synchronized 版本，双线程，生产者消费者 public class 虚假唤醒 { public static void main(String[] args) { Data data=new Data();
Java多线程之sleep带来的困惑
qq_35409525的博客
06-06 5101
  以前对多线程这一块了解的很少，经历过这几个月的春招备战，面试后，感觉多线程这一块是很多面试官经常问的，可以说对于我们来说这一块也是重中之重呀。其实当你接触了他以后，感觉多线程这个东西还是挺有意思的。所以接下来我就把我所知道 的了解的东西分享给大家，希望对大家有所帮助。  sleep()方法在多线程中也是经常用到的一个方法。sleep()方法的作用是让当前正在执行的线程进入休眠（暂停执行）。请看...
java - 多线程情境下产生的wait()虚假唤醒问题
qq_61777435的博客
10-10 390
一，是多线程环境（有多个线程拿到了同一个对象锁，并进行了wait()阻塞等待）。二，是拥有该对象锁的线程调用了notifyAll()方法。如果在多线程环境中满足了以上两个条件就有可能造成wait()虚假唤醒。
虚假唤醒详解
horacen的博客
04-28 5604
虚假唤醒详解        接触过多线程编程的朋友们或多或少都听说过虚假唤醒这一术语，我在百度上看了很多相关的帖子，说的都不是很清楚，于是写下这篇文章，希望能对大家有些裨益。 虚假唤醒是什么        首先我们来谈谈虚假唤醒到底是什么。在这里我给出一个自己的定义，帮助大家去理解虚假唤醒 虚假唤醒是一种现象，它只会出现在多线程环境中，指的是在多线程环境下，多个线程等
Java线程虚假唤醒是什么、如何避免？
健身变秃，coding变强
11-02 4325
一、什么是虚假唤醒？ 多线程环境下，有多个线程执行了wait()方法，需要其他线程执行notify()或者notifyAll()方法去唤醒它们，假如多个线程都被唤醒了，但是只有其中一部分是有用的唤醒操作，其余的唤醒都是无用功；对于不应该被唤醒的线程而言，便是虚假唤醒。 比如：仓库有货了才能出库，突然仓库入库了一个货品；这时所有的线程（货车）都被唤醒，来执行出库操作；实际上只有一个线程（货车）能执行出库操作，其他线程都是虚假唤醒。 下图为JAVA8中对wait()方法虚假唤醒的介绍： 意思是：虚假唤醒是可能
什么是虚假唤醒？为什么会产生虚假唤醒？
weixin_45668482的博客
05-28 9340
最近B站学习狂神的JUC并发编程时，听到了虚假唤醒这个词，虽然狂神进行了代码的演示，但我还是不太理解为什么使用if判断包装wait方法会出现虚假唤醒，查找了网上很多大佬的博客终于理解了，这里分享一下虚假唤醒产生的原因。 什么是虚假唤醒？ 当一定的条件触发时会唤醒很多在阻塞态的线程，但只有部分的线程唤醒是有用的，其余线程的唤醒是多余的。 比如说卖货，如果本来没有货物，突然进了一件货物，这时所有的顾客都被通知了，但是只能一个人买，所以其他人都是无用的通知。 虚假唤醒演示 public class test {
虚假唤醒分析
qq_43481605的博客
05-05 1115
一、虚假唤醒解读 首先我们要明白 if 和 while的区别 先直接看while和if的区别 可以看出来,if 是true情况下,if内的代码也只会执行一次 而while直至不满足条件才能跳出while循环 先分析while情况下 public class Demo { public static void main(String[] args) { Products data = new Products(); new Thread(() -> {
虚假唤醒spurious wakeup
qq_36553387的博客
08-25 400
虚假唤醒 虚假唤醒发生在：当线程从条件变量中苏醒过来时，发现等待的条件并没有满足。之所以被称为虚假，是因为线程被无缘无故的唤醒了。但是虚假唤醒不会无缘无故地发生：虚假唤醒通常是因为，在条件变量发出信号和等待线程最终运行之间，另一个线程运行并更改了条件。线程之间存在竞争条件。典型的结果是有时在条件变量上唤醒的线程首先运行，有时则不是首先运行。 在许多系统上，尤其是多进程系统上，虚假唤醒的问题会更严重，因为如果有多个线程在等待条件变量，在发出信号的时候，系统可能会决定将它们全部唤醒，将唤醒一个线程的signal
Java wait和notify虚假唤醒原理
08-19
Java中的`wait()`和`notify()`是用于多线程同步的关键方法，它们是Object类的成员，因此所有Java对象都可以调用。这两个方法是Java内存模型（JMM）的一部分，用于控制线程间的协作和通信。 `wait()`方法使得当前...
JAVA多线程同步机制及其应用.doc
06-10
Java多线程同步机制及其应用是Java编程中至关重要的一环，尤其在开发高并发、高性能的应用程序时，理解并掌握这些机制是必不可少的。本文档详细介绍了Java中多线程的相关概念、创建方式、线程管理、同步机制以及一个...
java多线程系列(三)等待通知机制.docx
06-21
在Java多线程编程中，等待通知机制是一种用于线程间高效通信的技术，它解决了线程之间因数据同步和协作而产生的问题。在上述的示例中，我们有两个线程，一个负责添加元素到列表（线程A），另一个则监控列表的大小...
Java面试题线程部分.docx
06-14
`wait`和`notify`是Object类的方法，用于线程间的等待和唤醒，它们必须在同步上下文中调用，以避免虚假唤醒。`yield`方法使当前线程让出执行权，但并不保证它不会立即重新获取执行权。 在Web开发中，Servlet、...
多线程：什么是虚假唤醒？为什么会产生虚假唤醒？
包磊磊的博客
10-21 470
最近B站学习狂神的JUC并发编程时，听到了虚假唤醒这个词，虽然狂神进行了代码的演示，但我还是不太理解为什么使用if判断包装wait方法会出现虚假唤醒，查找了网上很多大佬的博客终于理解了，这里分享一下虚假唤醒产生的原因。在步骤5中唤醒了阻塞队列中的消费者A线程，此时消费者A跳出 if 代码块消费产品并唤醒了生产者A线程、生产者B线程，由于时间片未结束，消费者A继续进入pop方法，但此时已经没有产品了，进入阻塞队列。消费者A的CPU时间片未结束，继续进入pop方法，但此时已没有产品了，进入阻塞队列并释放锁。
Java多线程中的虚假唤醒和如何避免
随机的未知——用已知去面对未知
12-03 424
先来看一个例子 一个卖面的面馆，有一个做面的厨师和一个吃面的食客，需要保证，厨师做一碗面，食客吃一碗面，不能一次性多做几碗面，更不能没有面的时候吃面；按照上述操作，进行十轮做面吃面的操作。 用代码说话 首先我们需要有一个资源类，里面包含面的数量，做面操作，吃面操作； 当面的数量为0时，厨师才做面，做完面，需要唤醒等待的食客，否则厨师需要等待食客吃完面才能做面； 当面的数量不为0时，食客才能吃面，吃完面需要唤醒正在等待的厨师，否则食客需要等待厨师做完面才能吃面； 然后在主类中，我们创建一个厨师线程进行10次做
Java多线程之虚假唤醒（原创）
Cratels学编程
03-31 1779
Java多线程之虚假唤醒 文章目录Java多线程之虚假唤醒虚假唤醒的定义从`生产者-消费者`场景讲起单生产者-单消费者场景多生产者-多消费者场景这就是虚假唤醒吗？ 首先需要说明的是，虚假唤醒不是Java语言特有的问题，而是多线程通信特有的问题，在java中就体现在sychronized-wait-notify上，最典型的应用场景就是生产者-消费者模式。 在网上翻看了很多关于虚假唤醒的文档，才发现大多数人说的都是错的。要么语焉不详，要么南辕北辙，不一而足。于是我决定自己写一篇文章来说一说：到底什么是虚假唤醒？
java 多线程中虚假唤醒
Primary_wind的专栏
07-18 419
多线程环境的编程中，我们经常遇到让多个线程等待在一个条件上，等到这个条件成立的时候我们再去唤醒这些线程，让它们接着往下执行代码的场景。假如某一时刻条件成立，所有的线程都被唤醒了，然后去竞争锁，因为同一时刻只会有一个线程能拿到锁，其他的线程都会阻塞到锁上无法往下执行，等到成功争抢到锁的线程消费完条件，释放了锁，后面的线程继续运行，拿到锁时这个条件很可能已经不满足了，这个时候线程应该继续在这个条件上阻塞下去，而不应该继续执行，如果继续执行了，就说发生了虚假唤醒。在这里我给出一个自己的定义，用来理解虚假唤醒。
Java 线程虚假唤醒问题
FLGB
08-04 363
虚假唤醒可能是由于操作系统或Java虚拟机的实现原因造成的。在某些情况下，线程可能会在没有明确通知的情况下从等待状态返回，而这并不是因为条件满足。虽然Java虚拟机通常会努力避免虚假唤醒，但程序员应该准备好处理这种情况。是指在多线程编程中，等待的线程在没有收到signal()或signalAll()通知的情况下，也可能被唤醒。这种情况是可能发生的，尽管在理论上不太常见。循环来检查条件是否满足，并在条件不满足时继续等待。这是因为虚假唤醒可能会导致线程在条件不满足时过早地继续执行，从而导致程序逻辑错误。
eclipse如何以指定JDK启动
热门推荐
buer
01-11 2万+
在开发过程中，高版本的eclipse往往只能使用高版本的JDK才能启动，低版本的eclipse也只能使用低版本的JDK才能启动。但是实际情况是，有的需要用高版本的JDK,有的需要用低版本的JDK。比如我用STS进行开发，JDK环境是1.6。而我的JAVA_HOME确实对应的JDK1.6所在路径。但是后面有个新需求，需要使用JDK1.8.由于JAVA_HOME只能对应一个路径。为了不产生冲突能让ec
java多线程中何为虚假唤醒？如何避免虚假唤醒？
最新发布
11-09
假唤醒是指在Java多线程中，一个线程在等待某个条件时，即使没有其他线程通知它，它也会被唤醒。这种情况可能会导致程序出现错误或异常。虚假唤醒通常是由于线程竞争条件的存在而引起的。 为了避免虚假唤醒，可以在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值