【Java】线程wait（） notify（）通信 实现生产者 消费者问题

最新推荐文章于 2022-04-11 16:51:14 发布
最新推荐文章于 2022-04-11 16:51:14 发布
阅读量882 收藏 3
点赞数 1
分类专栏： java 文章标签： 线程 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010900754/article/details/73729893
版权

wait和notify方法可以实现线程通信，模型类似于操作系统中的信号量。信号量其实就是一个变量，有一个等待的队列。java中任何对象都可以当做前面所谓的“信号量”，或者说，在java的模型中，是一个锁，任何对象都可以是一个锁。那么如何使用wait和notify呢？

假设现在有一段代码，这段代码可以被多个线程运行，如果检测到某一个条件成立，那么就需要将当前的线程等待，也就是wait。这里的wait通常是针对某一种资源或者一种条件。那么就可以用一个锁来标识具体某一种资源或者条件。锁内部就会维护这类资源的等待的线程，到时候唤醒就知道唤醒哪些线程了。所以说，wait和nofity必须依附于一个锁，也就是区分不用等待队列。也就是，wait和nofity必须是某一个对象的同步方法或者块。

下面是一个例子。

package ThreadTest;

public class Case1 {

	public static void main(String args[]){
		final String lock = "abc";
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					System.out.println(Thread.currentThread().getName() + " starts...");
					try {
						lock.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() +"  ends...");
				}
			}
		});
		t1.setName("t1");
		
		Thread t3 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					System.out.println(Thread.currentThread().getName() + " starts...");
					try {
						lock.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() +"  ends...");
				}
			}
		});
		t3.setName("t3");
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					//System.out.println(Thread.currentThread().getName() + " starts...");
					//lock.notify();
					//System.out.println(Thread.currentThread().getName() +"  ends...");
				}
			}
		});
		t2.setName("t2");
		
		t1.start();
		t2.start();
		t3.start();
	}
}
一个string对象是一个锁，可以代表某一种资源，有三个线程，t1和t3都需要wait，t2可以notify，如果把t2注释，那么会：


可以看到会被阻塞。如果t2取消注释：


可以看到其中的t1被唤醒，继续执行结束。

当一个线程执行到wait的同步区时，可定是得到了锁，当执行完以后，它会释放对象的锁，这样其他的线程可以得到锁，否则notify的线程也无法进入同步区。nofity方法会随机唤醒一个等待的线程，然后也会释放锁。那么wait和notify是什么时候释放的锁？

wait是刚执行完wait方法以后就释放锁，不会等待wait后面的同步区里面的方法的执行。而notify则是等待同步区的全部方法执行完才释放。

package ThreadTest;

public class Case2 {

	public static void main(String args[]){
		final String lock = "abc";
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					System.out.println(Thread.currentThread().getName() + " starts...");
					try {
						lock.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() +"  ends...");
				}
			}
		});
		t1.setName("t1");
		
		Thread t3 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					System.out.println(Thread.currentThread().getName() + " starts...");
					try {
						lock.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() +"  ends...");
				}
			}
		});
		t3.setName("t3");
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					//lock.notify();
				}
			}
		});
		t2.setName("t2");
		
		t1.start();
		//t2.start();
		t3.start();
	}
}
只有wait的两个线程执行，结果：


可以看到，如果是等到wait的同步块执行完才能释放锁，那么t1的end语句也应该被打印出来。而结果则是t3的starts先打印，说明wait执行完以后立刻释放锁，后面的代码也不会执行。

但是notify则是执行完同步块才释放的。

package ThreadTest;

public class Case2 {

	public static void main(String args[]){
		final String lock = "abc";
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					System.out.println(Thread.currentThread().getName() + " starts...");
					try {
						lock.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() +"  ends...");
				}
			}
		});
		t1.setName("t1");
		
		Thread t3 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					System.out.println(Thread.currentThread().getName() +"  starts...");
					lock.notify();
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() +"  ends...");
				}
			}
		});
		t3.setName("notify3");
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				synchronized(lock){
					System.out.println(Thread.currentThread().getName() +"  starts...");
					lock.notify();
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() +"  ends...");
				}
			}
		});
		t2.setName("notify2");
		
		t1.start();
		t2.start();
		t3.start();
	}
}
有两个notify的线程，每一个都会sleep一段时间，如果是执行完notify立刻释放，那么另一个线程是有机会执行的。但是结果：


说明，每一个notify的块执行完才轮到另一个notify执行，证明执行完块才释放的锁。

下面用wait notify机制实现一个生产者消费者问题。

package gggg;

import java.util.LinkedList;
import java.util.Queue;

class Pool {
	Queue<Integer> queue = new LinkedList<>();
	int size = 5;

	public Pool() {

	}

	public Pool(int size) {
		this.size = size;
	}
}

class P {
	Pool pool;

	public P(Pool pool) {
		this.pool = pool;
	}

	public void produce() {
		synchronized (pool) {
			System.out.println(Thread.currentThread().getName() + " wants to produces");
			if (pool.size <= pool.queue.size())
				try {
					pool.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName() + " produces");
			pool.queue.add(1);
			System.out.println(Thread.currentThread().getName() + " size is " + pool.queue.size());
			pool.notifyAll();
		}
	}
}

class C {
	Pool pool;

	public C(Pool pool) {
		this.pool = pool;
	}

	public void consume() {
		synchronized (pool) {
			System.out.println(Thread.currentThread().getName() + " wants to consume");
			if (pool.queue.size() <= 0)
				try {
					pool.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			pool.queue.poll();
			System.out.println(Thread.currentThread().getName() + " consumes");
			pool.notify();
		}
	}
}

public class Case4 {

	public static void main(String[] args) {
		Pool pool = new Pool();
		P p = new P(pool);
		C c = new C(pool);
		Thread tps = new Thread(new Runnable() {

			@Override
			public void run() {
				for(int i = 0 ;i < 100; i++){
					p.produce();
				}
			}
		});
		Thread tcs = new Thread(new Runnable() {

			@Override
			public void run() {
				for(int i = 0 ;i < 100; i++){
					c.consume();
				}
			}
		});
		tcs.start();
		tps.start();
	}

}

有一个缓存池，里面是一个队列，有存储上限值。为了简化，只有两个线程，一个生产一个消费。因此可以用pool做为锁，让wait操作和nofity以pool这个对象为锁。因为当生产者运行时，如果要唤醒，那么只可能唤醒消费者。

那如果要有多个线程呢？比如多个生产者线程和多个消费者线程。有两点需要改。第一个是这时就不能调用notify了，因为要唤醒多个生产者或者消费者，那么就只能使用notifyAll了。第二，如果现在是生产者要唤醒过个消费者，如果直接notify，不是也会唤醒其他的消费者么？确实有这样的问题。解决办法是把原本的if改为while，这样唤醒以后还要检测一次条件，不符而就重新wait，这就是多线程中该问题的设计，很巧妙。

package awge;

import java.util.LinkedList;
import java.util.Queue;

class Pool {
	Queue<Integer> queue = new LinkedList<>();
	int size = 5;

	public Pool() {

	}

	public Pool(int size) {
		this.size = size;
	}
}

class P {
	Pool pool;

	public P(Pool pool) {
		this.pool = pool;
	}

	public void produce() {
		synchronized (pool) {
			System.out.println(Thread.currentThread().getName() + " wants to produces");
			while (pool.size <= pool.queue.size())
				try {
					pool.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName() + " produces");
			pool.queue.add(1);
			System.out.println(Thread.currentThread().getName() + " size is " + pool.queue.size());
			pool.notifyAll();
		}
	}
}

class C {
	Pool pool;

	public C(Pool pool) {
		this.pool = pool;
	}

	public void consume() {
		synchronized (pool) {
			System.out.println(Thread.currentThread().getName() + " wants to consume");
			while (pool.queue.size() <= 0)
				try {
					pool.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			pool.queue.poll();
			System.out.println(Thread.currentThread().getName() + " consumes");
			pool.notifyAll();
		}
	}
}

public class Case4 {

	public static void main(String[] args) {
		Pool pool = new Pool();
		P p = new P(pool);
		C c = new C(pool);
		Thread[] tps = new Thread[100];
		Thread[] tcs = new Thread[100];
		for (int i = 0; i < tps.length; i++) {
			tps[i] = new Thread(new Runnable() {

				@Override
				public void run() {
					p.produce();
				}
			});
			tps[i].setName("p" + i);
			tcs[i] = new Thread(new Runnable() {

				@Override
				public void run() {
					c.consume();
				}
			});
			tcs[i].setName("c" + i);
		}

		for (int i = 0; i < tps.length; i++) {

			tcs[i].start();
		}
		for (int i = 0; i < tps.length; i++) {

			tps[i].start();
		}
	}
}


绝世好阿狸
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java—多线程的通信、生产者与消费者模式
12-21
一、重点知识 isDaemon 判断是否为守护线程。 run方法是不能用synchronized修饰，他是继承来的，不能改变其结构，而且，如果run方法加了synchronized，就变成单线程了，就没有并发了。 只要不是静态的同步方法，同步方法默认的同步监视器就是this。 静态的同步方法的同步监视器为类.class wait方法如果不是同步监视器去调用的话会报IllegalMonitorStateException异常 如果没有线程处于wait状态，调用notify此时是一个空唤醒 stringBuffer中的同步方法，都是非静态的，因为共用一个this锁就可以了，线程进去调用他的一个方法
Java 线程间通信，生产者与消费者模型
07-26
使用wait()和notify()实现的生产者与消费者模型，可以了解如何使用wait()和notify()进行线程间通信。（上一次上传的代码有一个问题没有考虑到，这次修补了——CSDN没法撤销资源，只能再上传了）
【java并发经典】生产者消费者问题（wait，notify）
小楼一夜听春雨
04-11 510
前言 我们都知道生产者消费者问题 有若干个生产者和消费者以及一个仓库 仓库里面容量一定，有以下几条规则： 1.生产者往仓库放东西，消费者往仓库消费东西 2.仓库满的时候，生产者无法放东西 3.仓库空的时候，消费者无法取东西 测试类 1.先构建一个仓库以供所有的生产者和消费者使用 2.把这个仓库作为构造函数的参数传给不同的生产者和消费者，让他们统一仓库 3.对不同的生产者和消费者赋予不同的名字，作为区分 4.先启动生产者的生产进程，睡一秒后，拉起两个消费者的消费进程 package product; /**
多线程之生产者消费者基本实现——wait/notify
【陈年风楼】的博客
10-10 521
生产者消费者问题是在面试过程中被面试官问到的最多的线程方面的问题，所以在这里发一个生产者消费者的最简单的实现方式
生产者和消费者问题（使用wait()+notify方式简单解决）
weixin_45041745的博客
08-14 732
wait()方法、notify()和notifyAll()方法 wait()方法、notify()和notifyAll()方法不是线程对象的方法，而是Object类中自带的方法，java中任何一个对象都有这三个方法。且这三个方法是建立在synchronized线程同步的基础之上的，必须与synchronized一起使用。 Object o = new Object; o.wait();//作用：让当前正在o对象上活动的线程（即当前线程）进入等待状态，进入该对象的等待池（是一种无限期等待，直至被唤醒）.
采用多线程技术，例如wait/notify，设计实现一个符合生产者和消费者问题的程序，对某一个对象（枪膛）进行操作，其最大容量是20颗子弹，生产者线程是一个压入线程，它不断向枪膛中压入子弹，消费者线程
luxuiary的博客
05-29 701
采用多线程技术，例如wait/notify，设计实现一个符合生产者和消费者问题的程序，对某一个对象（枪膛）进行操作，其最大容量是20颗子弹，生产者线程是一个压入线程，它不断向枪膛中压入子弹，消费者线程是一个射出线程，它不断从枪膛中射出子弹。 package com.kelley; public class Demo052901 { public static final Integer MAX_SIZE = 20; public static final Integer .
java多线程15 ：wait()和notify() 的生产者/消费者模式
weixin_33946020的博客
03-23 209
什么是生产者/消费者模型一种重要的模型，基于等待/通知机制。生产者/消费者模型描述的是有一块缓冲区作为仓库，生产者可将产品放入仓库，消费者可以从仓库中取出产品，生产者/消费者模型关注的是以下几个点：1、生产者生产的时候消费者不能消费2、消费者消费的时候生产者不能生产3、缓冲区空时消费者不能消费4、缓冲区满时生产者不能生产生产者/模型作为一种重要的模型，它的优点在于：1、解耦。因为多了一个缓冲区，所...
Java多线程问题--wait/notifyAll多生产者和多消费者
樊先知樊先知的博客
01-02 382
本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！ 代码地址：https://github.com/xianzhixianzhixian/thread.git 相关知识讲解 1、wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，知道接到通知或被中断位置。在wait()方法调用前，线程必须获得该对象的对象级...
使用wait/notify模拟生产者和消费者
weixin_34236497的博客
07-09 85
2019独角兽企业重金招聘Python工程师标准>>> ...
Java多线程——线程间通信之wait(),notify()方法,生产者与消费者模式实现,管道流
laoXingyao的博客
05-28 594
1.  wait()方法：使当前执行代码的线程进行等待。        在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法（否则会抛出IllegalMonitorStateException异常）。在执行wait()方法后，当前线程释放锁。在从wait()返回之前，线程与其他线程竞争重新获得锁。package threadCommunicatio...
Java实现生产者消费者问题
12-22
　生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，如下图所示，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况： 　生产者消费者...
用Python的线程来解决生产者消费问题的示例
12-25
我们将使用Python线程来解决Python中的生产者—消费者问题。这个问题完全不像他们在学校中说的那么难。 如果你对生产者—消费者问题有了解，看这篇博客会更有意义。 为什么要关心生产者—消费者问题： 可以帮你更好...
【并发编程】 — 线程间的通信wait、notify、notifyAll
12-21
三个线程顺序打印问题2.1.1 题目2.1.2 题目分析2.1.3 我的答案2.2 生产者消费者问题2.2.1 题目2.2.2 题目分析2.2.3 我的答案 源码地址：https://github.com/nieandsun/concurrent-study.git 1 wait、notify、...
多线程 wait-notify 写一段代码来解决生产者-消费者问题
苏凯的博客
02-28 1719
生产者-消费者 该模式在现实生活中很常见，在项目开发中也广泛应用，它是线程间通信的经典应用。 生产者是一堆线程，消费者是另一堆线程，内存缓冲区可以使用 List集合存储数据。该模式的关键之处是如何处理多线程之间的协调通信，内存缓冲区为空的时候，消费者...
面试题：用 wait-notify 写一段代码来解决生产者-消费者问题
w
02-24 7640
public class ProductTest { public static void main(String[] args) { Clerk clerk = new Clerk(); Thread producerThread = new Thread(new Producer(clerk)); Thread co
java多线程系列——（2）wait和notify方法实现生产者消费者问题
BodyCoding
07-13 338
1. 概要 Object类中提供有wait()、notify()、notifyAll()方法来使线程等待和唤醒。那么问题来了，为什么对线程的等待和唤醒要定义在object类中呢？ 因为wait(),notify(),notifyAll()都必须使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步 才具有锁。wait()会使“当前线程”等待，因为线程进入等待状态，所以线...
java多线程实现生产者消费者问题
weixin_44991304的博客
03-29 926
wait/notify机制实现原理 在使用wait/notify方法前我们需要对这两个方法进行简单的介绍： 使用wait/notify方法前提是拥有相同锁的线程才可以实现此机制。 1）wait方法是object的方法，他的作用是使当前执行wait方法的线程等待，在wait方法后面的代码暂停执行，并且释放锁，直到接到通知或被中断为止。在调用wait方法前，线程必须获得该对象的对象级别的锁，即只能在同步方法或同步代码块中调用wait方法。如果调用wait方法时没有适当的锁会抛出IllegalMonitorSta
用 wait-notify解决生产者-消费者问题
Hollake的博客
05-08 443
直接看代码，有注释 import java.util.LinkedList; import java.util.Queue; /** * Created by Administrator on 2019\5\8 0008. */ public class MyTest { public static void main(String[] args){ // 创建共...
高级色系PPT11.pptx
最新发布
05-08
高级色系PPT11.pptx
wait notify 实现消费者生产者
06-03
好的，下面是一个简单的使用wait()和notify()实现的生产者-消费者模型： ``` java public class ProducerConsumer { private List<Integer> buffer = new ArrayList<>(); private int maxSize = 5; public synchronized void produce() throws InterruptedException { while (buffer.size() == maxSize) { wait(); } int item = new Random().nextInt(); buffer.add(item); System.out.println("Produced: " + item); notify(); } public synchronized void consume() throws InterruptedException { while (buffer.size() == 0) { wait(); } int item = buffer.remove(0); System.out.println("Consumed: " + item); notify(); } } ``` 在上述代码中，`buffer`是一个用来存储生产者生产的数据的缓冲区，`maxSize`是缓冲区的最大大小，`produce()`和`consume()`分别表示生产者和消费者的行为。在`produce()`和`consume()`方法中，使用了`wait()`和`notify()`方法来实现线程的等待和唤醒。 在生产者线程中，如果缓冲区已满，就让线程等待（调用`wait()`方法）。如果缓冲区不满，就生产一个随机数，并且将其加入缓冲区中，然后唤醒等待的消费者线程（调用`notify()`方法）。 在消费者线程中，如果缓冲区为空，就让线程等待（调用`wait()`方法）。如果缓冲区不为空，就从缓冲区中取出一个数据，并且将其打印出来，然后唤醒等待的生产者线程（调用`notify()`方法）。 注意，以上代码仅作为示例，是一个比较简单的实现。在实际生产环境中，可能需要更加完善的实现方式来保证线程安全和性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值