public class MainThread
{
public static void main(String[] args)
{
// TODO Auto-generated method stub
Queue queue = new Queue(); //定义缓冲区;
Producer producer = new Producer(queue); //生产者
Consumer consumer = new Consumer(queue); //消费者
new Thread(producer).start();
new Thread(consumer).start();
}
}
/*注意:wait notify notifyAll只能在同步方法或同步块中调用*/
class Queue //queue表示队列
{
int product = 0;
boolean bfull = false;
public synchronized void setProduct(int product)
{
if (bfull)//如果队列已满,则调用wait等待消费者取走产品
{
try
{
wait();
}
catch (Exception e)
{
e.printStackTrace();
}
}
/*开始放置产品到队列中*/
this.product = product;
System.out.println("Producer set product:" + product);
bfull = true;
notify();//生产产品后通知消费者取走产品
}
public synchronized void getProduct()
{
if (!bfull)//如果队列是空的,则调用wait等待生产者生产产品
{
try
{
wait();
}
catch (Exception e)
{
e.printStackTrace();
}
}
/*开始从队列取走产品*/
System.out.println("Consumer get product:" + product);
bfull = false;
notify();//取走产品后通知生产者继续生产产品
}
}
class Producer implements Runnable
{
Queue queue;
Producer(Queue queue)
{
this.queue = queue;
}
public void run()//生产线程
{
for (int i = 1; i <= 10; i++)
{
queue.setProduct(i);
}
}
}
class Consumer implements Runnable
{
Queue queue;
Consumer(Queue queue)
{
this.queue = queue;
}
public void run()//消费线程
{
for (int i = 1; i <= 10; i++)
{
queue.getProduct();
}
}
}
/*
* Java 生产者-消费者案例框架
*“生产者-消费者”问题的含义是,
*系统中有很多生产者和消费者并
*发工作生产者负责生产资源,消费者消耗资源。
*当消费者消费资源时,如果资源不足,则需要等待,
*反之当生产者生产资源时,若资源已满,则也需要等待。
*另外同一时刻只能有一个生产者或消费者进行操作。
*/
//面包容器(资源)
class BreadContainer
{
// 容器的最大容量
public static final int maxNum = 300;
// 当前面包的数量
private int num;
// 无参构造器
public BreadContainer()
{
}
// 有参构造器
public BreadContainer(int num)
{
// 初始化面包数量
this.num = num;
}
// 制作面包的同步方法
public synchronized void produceBread(int produceNum, String ProducerSName)
{
// 测试是否可以生产面包
while (num + produceNum > maxNum)
{
// 面包充足,生产者等待
System.out.println(ProducerSName + "要生产" + produceNum + "个,当前" + num
+ "个,资源充足,不需要生产," + ProducerSName + "去等待!");
try
{
wait();
}
catch (Exception e)
{
e.printStackTrace();
}
}
// 满足条件后,生产者生产面包,刷新数量
num = num + produceNum;
System.out.println(ProducerSName + "生产了" + produceNum + "个,现在有" + num
+ "个。");
// 唤醒资源等待池中的所有线程
notifyAll();
}
public synchronized void consumeBread(int consumeNum, String ConsumerSName)
{
// 测试面包数量是否够消费
while (consumeNum > num)
{
// 不够数量,消费者等待
System.out.println(ConsumerSName + "要消费" + consumeNum + "个,由于现在只有"
+ num + "个," + ConsumerSName + "于是去等待!");
try
{
wait();
}
catch (Exception e)
{
e.printStackTrace();
}
}
// 数量充足,消费面包,刷新数量
num = num - consumeNum;
System.out.println(ConsumerSName + "消费了" + consumeNum + "个,现在还剩下" + num
+ "个");
// 唤醒资源等待池中的所有线程
this.notifyAll();
}
}
// 生产者类
class ProducerS extends Thread
{
// 记录该生产者一次生产的数量
private int produceNum;
// 生产者需要访问的面包容器资源
private BreadContainer bc;
// 无参构造器
public ProducerS()
{
}
// 有参构造器
public ProducerS(int produceNum, BreadContainer bc, String ProducerSName)
{
// 对线程进行初始化
this.produceNum = produceNum;
this.bc = bc;
this.setName(ProducerSName);
}
// 生产者的工作方法
public void run()
{
// 调用资源容器的同步方法生产资源
bc.produceBread(produceNum, this.getName());
}
}
// 消费者类
class ConsumerS extends Thread
{
// 记录该消费者一次消费的数量
private int consumeNum;
// 消费者需要访问的面包容器资源
private BreadContainer bc;
// 无参构造器
public ConsumerS()
{
}
// 有参构造器
public ConsumerS(int consumeNum, BreadContainer bc, String ConsumerSName)
{
// 对线程进行初始化
this.consumeNum = consumeNum;
this.bc = bc;
this.setName(ConsumerSName);
}
// 消费者的行为方法
public void run()
{
// 调用资源容器的同步方法生产资源
bc.consumeBread(consumeNum, this.getName());
}
}
public class Sample16_9
{
public static void main(String args[])
{
// 创建资源对象,初始面包有50个
BreadContainer bc = new BreadContainer(50);
// 创建对应的生产者和消费者
ProducerS p1 = new ProducerS(50, bc, "P1");
ProducerS p2 = new ProducerS(200, bc, "P2");
ProducerS p3 = new ProducerS(290, bc, "P3");
ConsumerS c1 = new ConsumerS(70, bc, "c1");
ConsumerS c2 = new ConsumerS(80, bc, "c2");
// 启动生产者消费者线程
c1.start();
c2.start();
p1.start();
p3.start();
p2.start();
}
}
分享到:
相关推荐
生产者与消费者实验报告生产者与消费者实验报告生产者与消费者实验报告生产者与消费者实验报告
生产者与消费者生产者与消费者生产者与消费者生产者与消费者生产者与消费者
生产者与消费者进程共享一个大小固定的缓冲区。其中,一个或多个生产者生产数据,并将生产的数据存入缓冲区,并有一个或多个消费者从缓冲区中取数据。 2、 系统设计: 系统的设计必须要体现进程之间的同步关系,...
生产者与消费者实验代码 关于进程的互斥访问 关于临界区的用处
用c语言 pv操作解决生产者与消费者问题
编写程序,运用Win32Api实现生产者与消费者使用缓冲区完成生产者与消费者的关系。模拟生产者和消费者的处理过程,程序中演示同步与互斥的关系。
操作系统生产者与消费者课程设计报告
模拟生产者与消费者问题,生产者和消费者同时向一个共享缓冲区放进和取出产品。
C#编写的有关操作系统中生产者与消费者问题的实例,画面美观,生动形象的描绘了生产者与消费者之间的关系,代码部分简介易懂。
生产者与消费者问题(操作系统)
通过实验模拟生产者与消费者之间的关系,了解并掌握他们之间的关系及其原理。由此增加对进程同步的问题的了解。 实验要求: 每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程
进程同步实验——生产者与消费者问题算法实现
C++ 用多方程解决生产者与消费者的问题
大连理工大学操作系统大作业, 进程同步与互斥 生产者与消费者问题
利用Java多线程实现的操作系统的生产者与消费者算法,主要用到了线程的同步,等待与唤醒操作。
Java生产者与消费者Demo
linux下的生产者与消费者实例,C实现,有注释,翻译的某个window下生产者与消费者的例子
利用Windows提供的API函数,编写程序,解决生产者与消费者问题,实现进程的互斥与同步。
使用的生产者和消费者模型具有如下特点: (1)本实验的多个缓冲区不是环形循环的,也不要求按顺序访问。生产者可以把产品放到目前某一个空缓冲区中。 (2)消费者只消费指定生产者的产品。 (3)在测试用例文件中指定...