生产者与消费者案例

(多线程的开发中最经典的操作案例,生产者不断生产产品,消费者不断取走产品)

public class Demo {
	/*
	 * 生产者、消费者问题
	 * 
	 * 生产者将产品交给店员,而消费者从店员取走产品,店员一次只能持有固定数量的产品,
	 * 如果生产者生产了过多的产品,店员会叫生产者等一下,如果店中有空位放产品了在通知生产者继续生产;
	 * 如果店中没有了产品,店员会告诉消费者等一下,如果店中有产品了再通知消费者取走产品。
	 *
	 */

}
//店员
public class Clerk {
	private int product=0;//产品默认为0
	//生产者生成出来的产品交给店员
	public synchronized void addProduct(){
		if(this.product>=20){
			try {
				wait();//产品已满,请稍等在生产
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
			product++;
			System.out.println("生产者生产地"+product+"个产品。");
			notifyAll();//通知等待区的消费者今天取产品了
		}
	}

	//消费者从店员处取产品
	public synchronized void getProduct(){
		if(this.product<=0){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
			System.out.println("消费者取走了第"+product+"个产品");
			product--;
			notifyAll();//通知等待区的生产者可以生产产品
		}
	}

}
//生产者线程要执行的任务
public class Producer implements Runnable {
	private Clerk cl;

	public Producer(Clerk cl) {
		this.cl = cl;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("生产者开始生产产品!");
		while(true){
			try {
				Thread.sleep((int)(Math.random()*10)*100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			cl.addProduct();
		}

	}	

}
//消费者线程要执行的任务
public class Consumer implements Runnable {
	private Clerk cl;

	public Consumer(Clerk cl) {
		super();
		this.cl = cl;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("消费者开始取走产品!");
		while(true){
			try {
				Thread.sleep((int)(Math.random()*10)*100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			cl.getProduct();//取走产品
		}
	}

}
//主线程
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Clerk cl=new Clerk();
		Thread prt=new Thread(new Producer(cl));//生产者线程
		Thread cot=new Thread(new Consumer(cl));//消费者线程
		prt.start();
		cot.start();

	}

}
时间: 2024-11-08 05:21:52

生产者与消费者案例的相关文章

生产者与消费者案例-虚假唤醒

以下是一个案例,有一个店员,负责进货和卖货.进货生产,卖货消费. 当商品超过10件,生产等待,消费继续,当少于0件,消费等待,消费继续. 正常代码如下: package com.atguigu.juc; /* * 生产者和消费者案例 */ public class TestProductorAndConsumer { public static void main(String[] args) { Clerk clerk = new Clerk(); Productor pro = new Pr

Java多线程与并发——生产者与消费者应用案例

多线程的开发中有一个最经典的操作案例,就是生产者-消费者,生产者不断生产产品,消费者不断取走产品. package com.vince; /** * 生产者与消费者案例 * @author Administrator * */ public class ThreadDemo4 { public static void main(String[] args) { // TODO 自动生成的方法存根 Food food=new Food(); Producter p=new Producter(fo

java 生产者 与 消费者的案例

主要理解了两个问题 1.线程数据同步的问题 2.线程交替运行的方式 package ThreadDemo; /** * 生产者与消费者的案例(一,同步的问题,值的问题 二,交替执行的问题) * @author lile * 同步的问题(synchronized 知识点) * 交替执行的问题(notify ,wait, 线程等待) */public class ThreadDemo { public static void main(String[] args) { Food food = new

Condition线程通信_生产者消费者案例

①Condition 接口描述了可能会与锁有关联的条件变量. 这些变量在用 法上与使用 Object.wait 访问的隐式监视器类似,但提供了更强大的 功能. 需要特别指出的是,单个 Lock 可能与多个 Condition 对象关 联. 为了避免兼容性问题,Condition 方法的名称与对应的 Object 版 本中的不同.② 在 Condition 对象中,与 wait.notify 和 notifyAll 方法对应的分别是 await.signal 和 signalAll.③ Condi

【转】通过生产者消费者案例理解等待唤醒机制和虚假唤醒

首先引入下面这段生产者和消费者的程序,店员类作为生产产品和消费产品的中介,其中的数据product为共享数据,产品最多只能囤积5个,当产品达到5个还在生产时,就会提示"产品已满!",类似地,如果产品只有0个了还在消费,会提示"缺货!": 1 package concurrent; 2 3 //店员类 4 class Clerk { 5 private int product = 0; 6 7 // 进货 8 public synchronized void get(

多线程生产者消费者案例

题目需求:写一个生产者消费者容器,支持多个生产者消费者同时访问,容器里最多放十个数,需要get()和put()方法,当容器中没数据时,生产者开始生产数据,消费者等待,数据量满十个时,生产者等待,消费者开始消费. /** * Created by canner on 2018/11/30. */ public class MyContainer<T> { private final int MAX = 10; private final LinkedList<T> list = ne

java多线程中的生产者与消费者之等待唤醒机制@Version1.0

一.生产者消费者模式的学生类成员变量生产与消费demo,第一版1.等待唤醒:    Object类中提供了三个方法:    wait():等待    notify():唤醒单个线程    notifyAll():唤醒所有线程2.为什么这些方法不定义在Thread类中呢?  这些方法的调用必须通过锁对象调用,而我们刚才使用的锁对象是任意锁对象.  所以,这些方法必须定义在Object类中.3.当我们在使用多线程的时候有的时候需要,一条线程产生一个数据,另一条线程接着消费一个数据,一边生产一边消费,

多线程_多生产者多消费者的实现问题

多生产者多消费者是Java中的一个经典的案例,采用等待唤醒机制来实现,代码如下: public class ProducerConsumer { public static void main(String[] args) { Resource res=new Resource(); Producer pro1=new Producer(res); Producer pro2=new Producer(res); Consumer con1=new Consumer(res); Consumer

多线程——生产者和消费者的问题

生产者和消费者问题的产生 生产者和消费者是指俩个不同的线程对象,操作统一资源的情况:生产者负责生产数据,消费者负责消费数据,生产者每生产完一组数据后,消费者  消费一组数据, Object对多线程的支持:  wait();等待被唤醒  notify();唤醒  notifyAll();唤醒所有 sleep()和wait()的区别: sleep()属于Thread类,类似于一个闹钟,只持续一定时间.wait()属于Object类,需要被notify()唤醒,如果不唤醒就会一直等待下去 具体案例如下