生产者与消费者 代码实现 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 ...
随机推荐
- cf919D 线性dp+拓扑排序
/* 给定一张有向图,图上每个结点都有一个字符,现在要求出一条路径,要使路径上某字符出现的次数最多 如果有环,输出-1即可 拓扑排序+dp dp[i][26]表示排序到结点i时26个字符出现的次数 在 ...
- swagger2访问url
swagger : http://localhost:8080/swagger/index.html springboot中的swagger:http://localhost:8080/swagger ...
- Android播放图片动画
1.布局文件中添加ImageView <ImageView android:id="@+id/iv_fan" android:layout_width="wrap_ ...
- 论文阅读笔记五：U-Net: Convolutional Networks for Biomedical Image Segmentation(CVPR2015)
前面介绍了两个文本检测的网络,分别为RRCNN和CTPN,接下来鄙人会介绍语义分割的一些经典网络,同样也是论文+代码实现的过程,这里记录一下自己学到的东西,首先从论文下手吧. 英文论文原文地址:htt ...
- 关于金蝶k3 wise供应生门户登陆界面屏蔽业务账套多余功能模块设置方法
关于金蝶k3 wise供应生门户登陆界面屏蔽业务账套多余功能模块设置方法 1. 找到以下路径 ...\Kingdee\K3ERP\KDHR\SITEFILE\WEBUI\ 找到“Login.aspx” ...
- jquery源码中noConflict(防止$和jQuery的命名冲突)的实现原理
jquery源码中noConflict(防止$和jQuery的命名冲突)的实现原理 最近在看jquery源码分析的视频教学,希望将视频中学到的知识用博客记录下来,更希望对有同样对jquery源码有困惑 ...
- Lambda表达式树构建（上）
概述 Lambda是C#常用的语句,采用委托等方式,来封装真实的代码块.Lambda其实就是语法糖,是一个匿名函数,是一种高效的类似于函数式编程的表达式,Lambda简化了开发中需要编写的代码量.它可 ...
- nginx做负载均衡 tomcat获得客户端真实ip
因项目需要做tomcat2台机器的负载均衡,配置好负载环境后,发现tomcat的日志一律是我前置nginx代理服务器的ip 通过百度教材发现需要修改nginx的配置文件,修改代理头信息,传递给后方,后 ...
- 【AtCoder】AGC032
AGC032 A - Limited Insertion 这题就是从后面找一个最靠后而且当前可以放的,可以放的条件是它的前面正好放了它的数值-1个数 如果不符合条件就退出 #include <b ...
- 一起学Hadoop——文件的上传、分发与打包
如果我们想把文件上传到Hadoop集群中,使用put命令即可.下面的语句是将本地文件上传到hadoop集群的/目录下. hadoop fs -put fruit.txt / 下面介绍通过脚本将文件 ...