生产者与消费者 代码实现 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 ...
随机推荐
- 小学生都看得懂的C语言入门(2): 判别 循环的一些应用实例
1.bool 类型 定义bool类型之前需要导入#include <stdbool.h> #include <stdio.h> #include <stdbool.h&g ...
- truncate table时存在外键约束的解决办法
以前在使用truncate命令时遇到表存在外键引用时无法执行命令的情况都是用delete来代替,今天又遇到这个问题,于是在网上搜了一把,可以通过如下方式解决: 1.基本思路:先关闭mysql的外键约束 ...
- 论文阅读笔记十四：Decoupled Deep Neural Network for Semi-supervised Semantic Segmentation（CVPR2015）
论文链接:https://arxiv.org/abs/1506.04924 摘要 该文提出了基于混合标签的半监督分割网络.与当前基于区域分类的单任务的分割方法不同,Decoupled 网络将分割与分类 ...
- 集腋成裘-05-angularJS -初识angular
私以为angular的最大特点是:只关注数据 1.1 angular之:双向绑定 <!DOCTYPE html> <html ng-app=""> < ...
- pycharm导入本地py文件时，模块下方出现红色波浪线时如何解决
有时候导入本地模块或者py文件时,下方会出现红色的波浪线,但不影响程序的正常运行,但是在查看源函数文件时,会出现问题 问题如下: 解决方案: 1. 进入设置,找到Console下的Python Co ...
- vs无法启动程序，操作在当前状态中是非法的
问题的图片: 解决方案: 工具--选项--调试--常规--启用asp.net的JavaScript调试(chrome和ie)去掉勾选
- Oracle数据库表索引失效，解决办法：修改Oracle数据库优化器模式
ALTER SYSTEM SET OPTIMIZER_MODE=RULE scope=both; 其他可以选择的模式还有ALL_ROWS/CHOOSE/FIRST_ROWS/ALL_ROWS. 应用系 ...
- .NetCore 下开发独立的（RPL）含有界面的组件包 （四）授权过滤
.NetCore 下开发独立的(RPL)含有界面的组件包 (一)准备工作 .NetCore 下开发独立的(RPL)含有界面的组件包 (二)扩展中间件及服 务 .NetCore 下开发独立的(RPL)含 ...
- 【AtCoder】AGC013
AGC013 A - Sorted Arrays 直接分就行 #include <bits/stdc++.h> #define fi first #define se second #de ...
- ip访问网站和localhost访问网站中top使用
对于相对定位,使用margin-top不用简单使用top. top在localhost中能正常显示,在ip访问时会出现多余空白. margin-top不管是localhost中还是ip中都能正常显示.