生产者与消费者 代码实现 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 ...
随机推荐
- Altium Designer (17.0) 打印输出指定的层
Altium Designer (17.0) 例如,打印输出Top Overlay,Keep-Out Layer 1.先选择PCB文件,在单击按键Print Preview... 2.在预览区单击鼠标 ...
- 如果IDEA右上角的tomcat消失了，解决办法
看了很多博客都没有找到解决办法,还是老师帮我解决的
- 几种stl的应用
1.set(特点:插入后元素自动从小到大排序) set< int > ::iterator it;//迭代器,可以指向同类型的集合 q.find(k);//其中一个元素k的地址 q.cou ...
- k3 Bos开发百问百答
K/3 BOS开发百问百答 (版本:V1.1) K3产品市场部 目录 一.基础资料篇__ 1 [摘要]bos基础资料的显示问题_ 1 [摘要]单 ...
- 【C++ Primer | 03】字符串、向量和数组
博客链接: c++ 中 const_iterator 和 const vector<>::iterator的区别 const vector <int> ::iterator和v ...
- SQL 查询表的第一条数据 和 最后一条数据
方法一: 使用TOP SELECT TOP 1 * FROM user; SELECT TOP 1 * FROM user order by id desc; 方法二: 使用LIMIT SELECT ...
- 網管利器！開源管理系統－LibreNMS
https://www.4rbj4.com/442 https://www.ichiayi.com/wiki/tech/librenms
- alpha冲刺8/10
目录 摘要 团队部分 个人部分 摘要 队名:小白吃 组长博客:hjj 作业博客:冲刺倒计时之8 团队部分 后敬甲(组长) 过去两天完成了哪些任务 首页重新设计 课程时间线确定 答辩准备 接下来的计划 ...
- Codeforces 348D Turtles LGV
Turtles 利用LGV转换成求行列式值. #include<bits/stdc++.h> #define LL long long #define fi first #define s ...
- 工具Maven
Maven 1.使用Maven后每个jar包只在本地仓库中保存一份,需要jar包的工程只需要维护一个文本形式的jar包的引用——我们称之为“坐标”. 2.Maven就可以替我们自动的将当前jar包所依 ...