生产者与消费者 代码实现 java
首先，我利用忙测试写出了第一次版本的代码
package How;
//自写代码 缺陷 无法完全实现pv操作线程处于忙测试状态
public class bin_1_1
{ public static void main(String[] args)
{
Producter producter; //生产者线程
Consumer consumer; //消费者线程
Buffer buffer;
buffer=new Buffer(10);
producter =new Producter(buffer);
consumer =new Consumer(buffer);
producter.start();
consumer.start();
} }
class Producter extends Thread
{
Buffer buffer;
public Producter(Buffer buffer)
{
this.buffer=buffer;
}
public void run()
{
while(true)
{ try
{
//模拟数据生产时间
Thread.sleep((int)Math.random()*5000+400);
IsEmpty(); //p(Empty)
//寻找空的缓存区 记录其标号为K
int k = 0;
for(int i=0; i<buffer.state_of_objs.length; i++)
{
if(buffer.state_of_objs[i]==0)
{
k=i;
break;
} }
write(k);
}
catch (InterruptedException e)
{ e.printStackTrace();
} }
}
synchronized public void IsEmpty() throws InterruptedException
{ while(true)
{
if(buffer.empty==0)
{
this.sleep(1);
}
else
{
buffer.empty--;
break;
}
}
}
public void write( int k ) //写入互斥，进制其他生产者访问
{
try
{
//模拟数据写入时间
Thread.sleep((int)Math.random()*1000+100);
//更改状态
System.out.println(Thread.currentThread().getName()+": 写"+k+"号缓存区");
buffer.state_of_objs[k]=1;
buffer.full++;
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
class Consumer extends Thread
{
Buffer buffer;
public Consumer(Buffer buffer)
{
this.buffer=buffer;
}
public void run()
{
while(true)
{
try
{
IsFull();
int k = 0;
for(int i=0; i<buffer.state_of_objs.length; i++)
{
if(buffer.state_of_objs[i]==1)
{
k=i;
break;
}
}
read(k);
//模拟消费时间
Thread.sleep((int)Math.random()*5000+300);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
synchronized public void IsFull() throws InterruptedException
{ while(true)
{
if(buffer.full==0)
{
this.sleep(1);
}
else
{
buffer.full--;
break;
}
}
}
public void read( int k)
{
try
{
//模拟读时间
Thread.sleep((int)Math.random()*3000+250);
System.out.println(Thread.currentThread().getName()+": 读"+k+"号缓存区");
//更改状态
buffer.state_of_objs[k]=0;
buffer.empty++;
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
class Buffer //缓存区 临界资源记录区
{
int size; //缓存区大小
Object[] objs; //
int full=0;
int empty;
int []state_of_objs;
public Buffer(int size)
{
this.size=size;
this.empty=size;
objs =new Object[size];
state_of_objs=new int[size];
for(int i=0; i<size; i++)
{
state_of_objs[i]=0;
}
}
} 针对上述情况我，参考了一些其他人的代码
package How;
//参考代码 主要学习线程的各种锁！
public class bin_1_2 {
private static Integer count = 0;
private final Integer FULL = 10;
private static String LOCK = "LOCK"; class Producer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (LOCK) {
while (count == FULL) {
try {
LOCK.wait();
} catch (Exception e) {
e.printStackTrace();
}
}
count++;
System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + count);
LOCK.notifyAll();
}
}
}
} class Consumer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(3000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
synchronized (LOCK) {
while (count == 0) {
try {
LOCK.wait();
} catch (Exception e) {
}
}
count--;
System.out.println(Thread.currentThread().getName() + "消费者消费，目前总共有" + count);
LOCK.notifyAll();
}
}
}
} public static void main(String[] args) throws Exception {
bin_1_2 bin_1_2 = new bin_1_2();
new Thread(bin_1_2.new Producer()).start();
new Thread(bin_1_2.new Consumer()).start();
new Thread(bin_1_2.new Producer()).start();
new Thread(bin_1_2.new Consumer()).start();
new Thread(bin_1_2.new Producer()).start();
new Thread(bin_1_2.new Consumer()).start();
new Thread(bin_1_2.new Producer()).start();
new Thread(bin_1_2.new Consumer()).start();
}
}
这个代码为 多个消费者，生产者的问题，通过这个代码，我了解了synchronized使用方式。
package How;
//参考代码
import java.util.LinkedList; public class bin_1_3 {
private LinkedList<Object> storeHouse = new LinkedList<Object>();
private int MAX = 10; public bin_1_3()
{
} public void start() {
new Producer().start();
new Comsumer().start();
} class Producer extends Thread {
public void run() {
while (true) {
synchronized (storeHouse) {
try {
while (storeHouse.size() == MAX) {
System.out.println("storeHouse is full , please wait");
storeHouse.wait();
}
Object newOb = new Object();
if (storeHouse.add(newOb)) {
System.out.println("Producer put a Object to storeHouse");
Thread.sleep((long) (Math.random() * 3000));
storeHouse.notify();
}
} catch (InterruptedException ie) {
System.out.println("producer is interrupted!");
} }
}
}
} class Comsumer extends Thread {
public void run() {
while (true) {
synchronized (storeHouse) {
try {
while (storeHouse.size() == 0) {
System.out.println("storeHouse is empty , please wait");
storeHouse.wait();
}
storeHouse.removeLast();
System.out.println("Comsumer get a Object from storeHouse");
Thread.sleep((long) (Math.random() * 3000));
storeHouse.notify();
} catch (InterruptedException ie) {
System.out.println("Consumer is interrupted");
} }
} }
} public static void main(String[] args) throws Exception {
bin_1_3 pc = new bin_1_3();
pc.start();
}
}
这个代码学习到了 LinkedList这个类库，从此我便可以快捷的方式实现栈，队列
最后我的改进代码如下：
package How;
class MyBuffer // 模拟缓冲区，这个为临界资源
{
String data; //模拟缓存区存放的数据
public MyBuffer(String data)
{
this.data=data;
}
} public class bin_1
{
public static void main(String[] args)
{
MyBuffer buffer=new MyBuffer("");
MyConsumer myConsumer=new MyConsumer(buffer);
MyProducter myProducter=new MyProducter(buffer);
myConsumer.start();
myProducter.start();
}
} class MyProducter extends Thread
{
MyBuffer buffer;
public MyProducter(MyBuffer buffer)
{
this.buffer=buffer;
}
//生产作业
public void ProducterJob()
{
//模拟生产时间
try
{
Thread.sleep((int )Math.random()*1000+400);
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
//进入互斥资源
synchronized (buffer)
{
if(buffer.data!="") //缓存区满着，阻塞
{
try
{
buffer.wait();
System.out.println("生产者等待");
Thread.sleep(500);
} catch (InterruptedException e)
{
e.printStackTrace(); }
}
buffer.data=""+System.currentTimeMillis();
System.out.println("生产者 ：生产的数据为"+buffer.data);
buffer.notify(); //唤醒消费者
}
}
public void run()
{
while(true)
{
ProducterJob();
}
}
}
class MyConsumer extends Thread
{
MyBuffer buffer;
public MyConsumer(MyBuffer buffer)
{
this.buffer=buffer;
}
//消费作业
public void ConsumerJob()
{
//模拟消费时间
try
{
Thread.sleep((int )Math.random()*1000+600);
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
//进入互斥资源
synchronized (buffer)
{
if(buffer.data=="") //缓存区为空，阻塞
{
try
{
buffer.wait();
System.out.println("消费者等待");
Thread.sleep(500);
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
System.out.println("消费者 ：消费的数据为"+buffer.data); buffer.data="";
buffer.notify(); //唤醒生产者
}
}
public void run()
{
while(true)
{
ConsumerJob();
}
}
}
运行结果：
生产者与消费者 代码实现 java的更多相关文章
- 基于kafka_2.11-2.1.0实现的生产者和消费者代码样例
1.搭建部署好zookeeper集群和kafka集群,这里省略. 启动zk: bin/zkServer.sh start conf/zoo.cfg. 验证zk是否启动成功: bin/zkServer. ...
- Kafka的生产者和消费者代码解析
:Kafka名词解释和工作方式 1.1:Producer :消息生产者,就是向kafka broker发消息的客户端. 1.2:Consumer :消息消费者,向kafka broker取消息的客户端 ...
- RabbitMQ的使用（五）RabbitMQ Java Client简单生产者、消费者代码示例
pom文件: <dependencies> <dependency> <groupId>com.rabbitmq</groupId> <artif ...
- 菜鸡的Java笔记 生产者与消费者
生产者与消费者 代码要求知道做什么用即可 线程间的通讯问题以及 Object 类的支持 基础模型 现在希望实现一种数据的生产和取出的操作 ...
- 生产者-消费者问题【Java实现】
生产者-消费者问题是经典的并发问题, 非常适合并发入门的编程练习. 生产者-消费者问题是指, 有若干个生产者和若干个消费者并发地读写一个或多个共享存储空间:生产者创建对象并放入到共享存储空间,消费 ...
- java多线程中的生产者与消费者之等待唤醒机制@Version1.0
一.生产者消费者模式的学生类成员变量生产与消费demo,第一版1.等待唤醒: Object类中提供了三个方法: wait():等待 notify():唤醒单个线程 notify ...
- java之生产者与消费者
package com.produce; import java.util.LinkedList; import java.util.Queue; /*@author shijin * 生产者与消费者 ...
- Android（java）学习笔记71：生产者和消费者之等待唤醒机制
1. 首先我们根据梳理我们之前Android(java)学习笔记70中关于生产者和消费者程序思路: 2. 下面我们就要重点介绍这个等待唤醒机制: (1)第一步:还是先通过代码体现出等待唤醒机制 pac ...
- Java 多线程-生产者、消费者
一.整体代码 ThreadDemo.java public class ThreadDemo { public static void main(String[] args) { Godown god ...
随机推荐
- poj2441状态压缩dp基础
/* 给定n头牛,m个谷仓,每头牛只能在一些特定的谷仓,一个谷仓只能有一头牛 问可行的安排方式 dp[i][j]表示前i头牛组成状态j的方案数,状态0表示无牛,1表示有牛 使用滚动数组即可 枚举到第i ...
- 流媒体服务器SRS部署
github地址:https://github.com/ossrs/srs 1,srs下载 http://ossrs.net/srs.release/releases/index.html 选择正式发 ...
- 类和JSP关系
404的原因.除了路径问题,还有文件放置位置.比如如果文件在web-inf下面.浏览器是访问不到的
- 有一个字典对象，d = {'a':1,'b':2}，请用尽量简洁的代码将d转换成{1: 'a', 2: 'b'}
题目:有一个字典对象,d = {'a':1,'b':2},请用尽量简洁的代码将d转换成{1: 'a', 2: 'b'} 第一种方法: d = {'a': 1, 'b': 2}d = {value: k ...
- python练习册0004题
在任意一个英文文档中,统计单词出现的次数, 分析: 本题不是很难,单词通常以空格隔开,但是有些单词后面跟一些特殊符号,只需把这些特殊符号替换掉就可以了, 代码一 import re file_name ...
- 一元线性回归与R语言
(https://mirrors.tuna.tsinghua.edu.cn/CRAN/)下载好R之后打开,就可以输入命令,如下,我输入 > y=c(61,57,58,40,90,35,68) ...
- [转] JavaScript 之 ArrayBuffer
JS里的ArrayBuffer 还记得某个晚上在做 canvas 像素级操作,发现存储像素的数据格式并不是Array类型,而是ArrayBuffer,心想这是什么鬼?后来查了一些资料,发现自己这半年来 ...
- javascript 列表定时滚动效果
HTML结构: <div style="width:200px;height:100px;overflow:hidden;border:1px solid #ddd;margin:20 ...
- MVC和Web API 过滤器Filter
MVC和Web API Filter(过滤器) ASP.NET MVC 支持以下类型的操作筛选器: · 授权筛选器.这些筛选器用于实现IAuthorizationFilter和做出关于是 ...
- python全栈开发day57- pymysql、视图、触发器、函数
一.昨日内容回顾 1.单表查询 优先级 from where group by having select distinct order by limit 2 . 多表查询 inner join... ...