消费者生产者的关系

package com.young.day021;

public class Clerk {

private int product=0;//产品默认0;

//生产者生成出来的产品交给店员

public synchronized void addProduct(){

if(this.product>=20){

try {

wait();//产品已满,请稍等在生产

} catch (InterruptedException e) {

// TODO 自动生成的 catch 块

e.printStackTrace();

}

}else{

product++;

System.out.println("生产者生产地"+product+"个产品。");

notifyAll(); //通知等待区的消费者今天取产品了

}

}

//消费者从店员处取产品

public synchronized void getProduct(){

if(this.product<=0){

try {

wait();//产品没有货了,请稍等再取

} catch (InterruptedException e) {

// TODO 自动生成的 catch 块

e.printStackTrace();

}

}else{

System.out.println("消费者取走了第"+product+"个产品");

product--;

notifyAll();//通知等待区的生成者可以生产 产品

}

}

}

=================================================================================

package com.young.day021;

//消费者线程要执行的任务

public class Consumer implements Runnable {

private Clerk cl;

public Consumer(Clerk cl) {

this.cl=cl;

}

public void run() {

System.out.println("消费者开始取走产品!");

while(true){

try {

Thread.sleep((int)(Math.random()*10)*100);

} catch (InterruptedException e) {

// TODO 自动生成的 catch 块

e.printStackTrace();

}

cl.getProduct();//取走产品

}

}

}

===========================================================================================

package com.young.day021;

import javax.swing.plaf.synth.SynthSpinnerUI;

//生产者线程要执行的任务

public class Producer implements Runnable {

private Clerk cl;

public Producer(Clerk cl){

this.cl=cl;

}

public void run() {

System.out.println("生产者开始生产产品!");

while(true){

try {

Thread.sleep((int)(Math.random()*10)*100);

} catch (InterruptedException e) {

// TODO 自动生成的 catch 块

e.printStackTrace();

}

cl.addProduct();//生产产品

}

}

}


========================================================================================

package com.young.day021;

public class Main {

public static void main(String[] args) {

// TODO 自动生成的方法存根

Clerk cl=new Clerk();

Thread prt=new Thread(new Producer(cl));//生产者线程

Thread cot=new Thread(new Consumer(cl));//消费者线程

prt.start();

cot.start();

}

}

时间: 2024-10-15 00:34:44

消费者生产者的关系的相关文章

java 与操作系统进程同步问题(二)————经典消费者生产者问题

http://www.cnblogs.com/zyp4614/p/6033757.html (java 与操作系统进程同步问题(一)----互斥问题) 今天写的是最经典的生产者消费者问题,最简单的版本,即只有一个缓冲区,缓冲区中只能放一个物品,即不考虑互斥关系. 问题简单分析: 生产者在缓冲区为空的时候可以往缓冲区中放产品,消费者可以在缓冲区不空(即缓冲区中有产品时)可以取一个产品. 首先可以确定有两个信号量 第一个信号量,是缓冲区是否空,当空的时候生产者可以放入产品,初值为1,因为默认缓冲区是

java消费者生产者模式及JDK之阻塞队列LinkedBlockingQueue实现

生产者消费者问题 (英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例.该问题描述了两个共享固定大小缓冲区的线程--即所谓的"生产者"和"消费者"--在实际运行时会发生的问题.生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程.与此同时,消费者也在缓冲区消耗这些数据.该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空

java多线程同步以及线程间通信详解&amp;消费者生产者模式&amp;死锁&amp;Thread.join()(多线程编程之二)

本篇我们将讨论以下知识点: 1.线程同步问题的产生 什么是线程同步问题,我们先来看一段卖票系统的代码,然后再分析这个问题: [java] view plain copy print? package com.zejian.test; /** * @author zejian * @time 2016年3月12日 下午2:55:42 * @decrition 模拟卖票线程 */ public class Ticket implements Runnable { //当前拥有的票数 private 

ReentrantLock Condition 实现消费者生产者问题

import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; //产品 class Product

java多线程之消费者生产者模式

/*@author shijin * 生产者与消费者模型中,要保证以下几点: * 1 同一时间内只能有一个生产者生产     生产方法加锁sychronized * 2 同一时间内只能有一个消费者消费     消费方法加锁sychronized * 3 生产者生产的同时消费者不能消费     生产方法加锁sychronized * 4 消费者消费的同时生产者不能生产     消费方法加锁sychronized * 5 共享空间空时消费者不能继续消费     消费前循环判断是否为空,空的话将该线程

多线程之消费者生产者模式加入阻塞队列

队列相关资料: http://chenjumin.iteye.com/blog/2182322 http://blog.csdn.net/luohuacanyue/article/details/16359777 Queue ------------ 1.ArrayDeque, (数组双端队列) 2.PriorityQueue, (优先级队列) 3.ConcurrentLinkedQueue, (基于链表的并发队列) 4.DelayQueue, (延期阻塞队列)(阻塞队列实现了BlockingQ

JAVA多线程关于消费者/生产者的设计模式

1 import javax.swing.plaf.SliderUI; 2 3 /* 4 * 生产者Producter 5 * 仓库Godown 6 * 消费者 Consumer 7 * 生产者和消费者通过仓库而建立起联系,仓库的当前数量低于最大库存量时,生产者线程不断生产产品(修改Godown类的属性的值) 8 * 仓库的产品数量大于0时,消费者不断取出产品(修改Godown类的属性的值).当生产者生产的产品等于最大库存值时, 9 * 停止生产,当产品数量小于0时,消费者停止消费 10 * 1

c 消费者生产者V2

增加了buffsize,生产者生产过多,wait #include <stdio.h> #include <unistd.h> #include <pthread.h> #define PRODUCER_SIZE 1 #define CONSUMER_SIZE 1 int products = 0; int buffsize = 5; pthread_mutex_t mutex; pthread_cond_t empty_cond; pthread_cond_t ful

线程 同步与互斥-------消费者 生产者模型

  1 #include<stdio.h>   2 #include<pthread.h>   3 #include<stdlib.h>   4    5 static int i = 1;   6 pthread_mutex_t lock;   7 pthread_mutex_t lock1;   8 pthread_cond_t cond;   9 typedef struct node  10 {  11     int _data;  12     struct