关闭

生产消费模式的几种实现

79人阅读 评论(0) 收藏 举报

直接上代码!!

第一种

package test;


import java.util.Random;




public class Demo1 {
//基于yield退让
public static void main(String[] args) {
Send send = new Send();
Reci rec = new Reci(send);
Thread t1 = new Thread(send);
t1.setDaemon(true);//当只有t1线程,程序退出(守护线程)
Thread t2 = new Thread(rec);
t2.setPriority(6);
t2.setName("r2");
Thread t3 = new Thread(rec);
t3.setPriority(7);
t3.setName("r3");
Thread t4 = new Thread(rec);
t4.setPriority(8);
t4.setName("r4");
Thread t5 = new Thread(rec);
t5.setPriority(10);
t5.setName("r5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
class Send extends Thread{
boolean flag;
int value;
@Override
public   void run() {
// TODO Auto-generated method stub
for (;;) {
while(flag){
Thread.yield();
}
value=new Random().nextInt();
System.out.println("制作好食物"+value);
flag=true;
}
}
}
class Reci extends Thread{
private Send send;


public Reci(Send send) {
super();
this.send = send;
}
@Override
public synchronized void run() {
// TODO Auto-generated method stub
System.out.println("线程"+Thread.currentThread().getName()+"开吃");
while(!send.flag){
Thread.yield();//下次接着运行,时间片轮换,这个对象锁并没有被放弃,只要是这个对象下次接着来,也就是说在当前线程重新回到CPU上运行之前,其他线程都不能使用run方法。
}
System.out.println(Thread.currentThread().getName()+

"已经消费食物"+send.value);
send.flag=false;
System.out.println(Thread.currentThread().getName()+"吃完");
}


}




/*开吃
制作好食物-1900039954
r2已经消费食物-1900039954
吃完
开吃
制作好食物-851625431  //被迫做食物,食客在等
r5已经消费食物-851625431
吃完
开吃
制作好食物1038626377
r4已经消费食物1038626377
吃完
制作好食物1175664726  //主动做食物,现在没客人(客人啥都吃不挑食)
开吃
r3已经消费食物1175664726
吃完
制作好食物1727535480
*/





第二种

package test;


import java.util.Random;


public class Demo2 {
public static void main(String[] args) {
Send1 send = new Send1();
Reci1 rec = new Reci1(send);
Thread t1 = new Thread(send);
t1.setDaemon(true);
Thread t2 = new Thread(rec);
t2.setPriority(10);
t2.setName("r2");
Thread t3 = new Thread(rec);
t3.setPriority(10);
t3.setName("r3");
Thread t4 = new Thread(rec);
t4.setPriority(10);
t4.setName("r4");
Thread t5 = new Thread(rec);
t5.setPriority(10);
t5.setName("r5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}


}
class Send1 implements Runnable{
boolean flag;
int value;
public  void run(){
synchronized (this) {
for (;;) {
while(flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
value=new Random().nextInt();
System.out.println("已经生产食物"+value);
flag=true;
this.notifyAll();
}
}
}

}
class Reci1 implements Runnable{
private Send1 send;


public Reci1(Send1 send) {
super();
this.send = send;
}
public  void run(){
synchronized (this) {//保证同步
synchronized (send) {//因为下面要调用send,wait(),所以锁的对象是send
System.out.println("开吃");
while(!send.flag){
try {
send.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"已经消费食物:"+send.value);
send.flag=false;
send.notifyAll();
System.out.println("吃完");
}

}

}
}
/*已经生产食物964920772  
开吃
r2已经消费食物:964920772
吃完
开吃
已经生产食物-1103227087  //被迫生产客户在等aaa
r5已经消费食物:-1103227087
吃完
已经生产食物-14069138   //主动生产,客户不挑食,啥都吃
开吃
r4已经消费食物:-14069138
吃完
已经生产食物2082765831
开吃
r3已经消费食物:2082765831
吃完
已经生产食物1728566631*/





第三种

package test;


import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class Demo3 {
public static void main(String[] args) {
final Business business = new Business();
Thread send = new Thread(){
public void run() {
business.send();
};
};
send.setDaemon(true);
send.start();

Thread reci1 = new Thread(){
public void run() {
business.reci();;
};
};
reci1.setName("r1");
Thread reci2 = new Thread(){
public void run() {
business.reci();;
};
};
reci2.setName("r2");
Thread reci3 = new Thread(){
public void run() {
business.reci();;
};
};
reci3.setName("r3");
Thread reci4 = new Thread(){
public void run() {
business.reci();;
};
};
reci4.setName("r4");

reci1.start();
reci2.start();
reci3.start();
reci4.start();





}}
class Business{
Integer value=new Integer(0);
Boolean flag=new Boolean(false);
Object o=new Object();//什么用?用于调用wait、nitify
public  void send(){
for (;;) {
synchronized (o) {
while(flag){
try {
o.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
value=new Integer(new Random().nextInt());
System.out.println("已经生产食物"+value);
flag=true;
o.notifyAll();
}

}
}
public synchronized void reci(){
synchronized (o) {
System.out.println(Thread.currentThread().getName()+"开吃");
while(!flag){
try {
o.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"已经消费食物:"+value);
flag=false;
System.out.println(Thread.currentThread().getName()+"吃完");
o.notifyAll();
}

}
}




0
0
查看评论

关于java多线程浅析一:简单实现生产消费模式

关于什么是线程,这里就不过多介绍了。但为什么要用多线程呢?原因无他,就是希望更好的利用CPU资源。当然,多线程在模拟很多实际场景下,也是一把利器,就比如生产-消费模式,使用不同的线程来充当生产者和消费者,就很容易实现一个简单的生产-消费模型。说到此,那我们就先利用线程中的wait()和notifyA...
  • zhangjunfei12103323
  • zhangjunfei12103323
  • 2017-05-11 15:01
  • 1146

并发模式(三)——生产者-消费模式

生产者-消费模式
  • lmdcszh
  • lmdcszh
  • 2014-09-30 21:03
  • 4241

java多线程之生产消费模式

/*@author shijin  * 生产者与消费者模型中,要保证以下几点:  * 1 同一时间内只能有一个生产者生产     生产方法加锁sychronized  *&#...
  • BloodyDmusic
  • BloodyDmusic
  • 2016-07-22 13:01
  • 876

Redis 学习笔记十 发布者订阅者模式与生产者消费者模式

发布/订阅,类似设计模式中的观察者模式。 redis可以作为pub/sub的服务端。订阅得通过subscribe和psubscribe命令向redis server订阅消息类型,redis将消息类型称为channel。 当发布者通过publish命令向redis server发送特定消息时,访问...
  • xundh
  • xundh
  • 2017-01-09 14:35
  • 3961

Java实现生产者消费者模型

生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类:(1)采用某种机制保护生产者和消费者之间的同步;(2)在生产者和消费者之间建立一个管道。第一种方式有较高的效率,并且易...
  • ILOVESMJ
  • ILOVESMJ
  • 2016-09-19 17:07
  • 6543

简单生产消费模式的代码流程(Java代码)

简单生产消费模式的代码流程(Java代码)
  • starjuly
  • starjuly
  • 2016-12-11 16:00
  • 924

IOS 生产者-消费者模型实现

// // ViewController.m // pc_mode // // Created by ise on 16/1/25. // Copyright © 2016年 lzb. All rights reserved. // #import "ViewContr...
  • qq_23505655
  • qq_23505655
  • 2016-01-25 10:32
  • 1179

高并发:阻塞队列 实现生产者-消费者模式

首先介绍一下非阻塞队列,比如PriorityQueue、LinkedList。在使用非阻塞队列时遇到的问题:不会对当前线程产生阻塞,在面对类似消费者-生产者的模型时,必须额外地实现同步策略以及线程间唤醒策略,这个实现起来非常麻烦。 所以,阻塞队列恰恰不一样,阻塞队列会对当前线程产生阻塞,比如一个线...
  • g893465244
  • g893465244
  • 2016-09-12 11:32
  • 2584

JS实现经典生产者消费者模型

使用node的定时器timer实现经典的生产者消费者模型。
  • shishuo365
  • shishuo365
  • 2014-07-05 09:29
  • 2504

生产/消费模式实现

生产与消费模式是等待与通知机制的一种典型实现, 也就是使用wait和notify方法或wait和notifyAll方法组合 实现生产与消费模式。 以下为单个生产者和单个消费者完成的生产/消费模式。 1. 定义生产/消费共享数据存储结构 package com.lanhuigu.J...
  • yhl_jxy
  • yhl_jxy
  • 2017-07-26 23:26
  • 220
    个人资料
    • 访问:1444次
    • 积分:93
    • 等级:
    • 排名:千里之外
    • 原创:8篇
    • 转载:0篇
    • 译文:0篇
    • 评论:2条