文档章节

六种方式实现生产者消费者(未完)

特拉仔
 特拉仔
发布于 2017/06/02 09:54
字数 706
阅读 4
收藏 0

一、利用Object对象是wait和notify\notifyAll

    

package com.jv.parallel.consumerandproducer.objectwait;

public class Car {
	private volatile int flag = 0;
	public void showConsumer(){
		System.out.println("I am a Car ! 我已经被消费");
	}
	public void showProducer(){
		System.out.println("I am a Car ! 我已经被生产");
	}
	public int getFlag(){
		return flag;
	}
	public void setFlag(int flag){
		this.flag=flag;
	}
}

 

package com.jv.parallel.consumerandproducer.objectwait;

public class Consumer extends Thread{
	private Car car;
	
	public Consumer() {
		// TODO Auto-generated constructor stub
	}
	
	public Consumer(Car car){
		this.car = car;
	}
	
	@Override
	public void run() {
		while(true){
			synchronized(car){
				try {
					while(car.getFlag()==0){
							car.wait();
					}
						car.setFlag(0);
						car.showConsumer();
						car.notifyAll();
						Thread.currentThread().sleep(1000);
					
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

 

package com.jv.parallel.consumerandproducer.objectwait;

public class Producer extends Thread{
	private Car car;
	
	public Producer(){
		
	}
	
	public Producer(Car car){
		this.car = car;
	}
	
	public void run() {
		while(true){
			synchronized(car){
				try {
					while(car.getFlag()==1){
							car.wait();
					}
						car.setFlag(1);
						car.showProducer();
						car.notifyAll();
						Thread.currentThread().sleep(1000);
					
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

 

package com.jv.parallel.consumerandproducer.objectwait;

public class Test {
	public static void main(String[] args) {
		Car car  = new Car();
		Consumer cs = new Consumer(car);
		Producer pd = new Producer(car);
		cs.start();
		pd.start();
	}
}

 

二、使用Lock.Condition

    

package com.jv.parallel.consumerandproducer.lock;

public class Car {
	private volatile int flag = 0;
	public void showConsumer(){
		System.out.println("I am a Car ! 我已经被消费");
	}
	public void showProducer(){
		System.out.println("I am a Car ! 我已经被生产");
	}
	public int getFlag(){
		return flag;
	}
	public void setFlag(int flag){
		this.flag=flag;
	}
}
package com.jv.parallel.consumerandproducer.lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Consumer implements Runnable{
	
	private Car car;
	private Lock lock;
	private Condition cd ;
	
	public Consumer() {
		// TODO Auto-generated constructor stub
	}
	
	public Consumer(Car car,Lock lock,Condition cd){
		this.car=car;
		this.lock=lock;
		this.cd=cd;
	}

	@Override
	public void run() {
		while(true){
			lock.lock();
			try{
				while(car.getFlag()==0){
					cd.await();
				}
					car.setFlag(0);
					car.showConsumer();
					cd.signal();
					Thread.currentThread().sleep(1000);
				
			} catch (InterruptedException e) {
				e.printStackTrace();
			}finally{
				lock.unlock();
			}
		}
	}
}
package com.jv.parallel.consumerandproducer.lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Producer implements Runnable{
	private Car car;
	private Lock lock;
	private Condition cd ;
	
	public Producer() {
		// TODO Auto-generated constructor stub
	}
	
	public Producer(Car car,Lock lock,Condition cd){
		this.car=car;
		this.lock=lock;
		this.cd=cd;
	}

	@Override
	public void run() {
		while(true){
			lock.lock();
			try{
				while(car.getFlag()==1){
					cd.await();
				}
					car.setFlag(1);
					car.showProducer();
					cd.signal();
					Thread.currentThread().sleep(1000);
				
			} catch (InterruptedException e) {
				e.printStackTrace();
			}finally{
				lock.unlock();
			}
		}
	}
}
package com.jv.parallel.consumerandproducer.lock;

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

public class Test {
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		Car car = new Car();
		Condition cd = lock.newCondition();
		Thread t1 = new Thread(new Consumer(car,lock,cd));
		Thread t2 = new Thread(new Producer(car,lock,cd));
		t1.start();
		t2.start();
	}
}

 

三、使用阻塞队列

设置阻塞队列长度为1,使用put和take方法(可阻塞)

package com.jv.consumerandproducer.queue;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class TestQueue {	
	public static void main(String[] args) {
		BlockingQueue<Car> queue = new ArrayBlockingQueue<Car>(1);
		Consumer c = new Consumer(queue);
		Producer p = new Producer(queue);
		Thread t1 = new Thread(c);
		Thread t2 = new Thread(p);
		t1.start();
		t2.start();
		System.out.println("main haved end");
	}
	
}
class Consumer implements Runnable{
	BlockingQueue<Car> queue;
	public Consumer(BlockingQueue<Car> queue){
		this.queue=queue;
	}

	@Override
	public void run() {
		Car c ;
		while(true){
			try {
				c = queue.take();
				c.showConsumer();
				Thread.currentThread().sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}

class Producer implements Runnable{
	BlockingQueue<Car> queue;
	public Producer(BlockingQueue<Car> queue){
		this.queue=queue;
	}
	@Override
	public void run() {
		Car c ;
		while(true){
			try{
				c = new Car();
				queue.put(c);
				c.showProducer();
				Thread.currentThread().sleep(1000);
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}
package com.jv.consumerandproducer.queue;

public class Car {
	private volatile int flag = 0;
	public void showConsumer(){
		System.out.println("I am a Car ! 我已经被消费");
	}
	public void showProducer(){
		System.out.println("I am a Car ! 我已经被生产");
	}
	public int getFlag(){
		return flag;
	}
	public void setFlag(int flag){
		this.flag=flag;
	}
}

四、利用FutureTask实现

    还需要研究它的内部实现原理

    代码待补充

五、使用信号量实现

    其内部原理还是利用被包装过的同步器的condition对象实现

    代码待补充

六、使用Redis列表数据类型实现

    因为它具有可阻塞特性。

    代码待补充

© 著作权归作者所有

共有 人打赏支持
特拉仔
粉丝 32
博文 188
码字总数 167470
作品 0
渝中
项目经理
Java实现生产者-消费者模型

考查Java的并发编程时,手写“生产者-消费者模型”是一个经典问题。有如下几个考点: 对Java并发模型的理解 对Java并发编程接口的熟练程度 bug free coding style JDK版本:oracle java 1.8...

monkeysayhi
2017/11/20
0
0
[高并发Java 七] 并发设计模式

什么是设计模式 在软件工程中,设计模式(design pattern)是对软件设计中普遍存在(反复出现)的各种问题 ,所提出的解决方案。这个术语是由埃里希·伽玛(Erich Gamma)等人在1990年代从建...

Hosee
2016/02/14
6.7K
0
Linux 下多线程的消费者-生产者模型

消费者-生产者模型 所谓这个模型指在ipc时,由扮演的生产者进程产生数据,由扮演消费者的进程去拿走数据。 这个模型是由3种关系俩种角色一个场景所描述而成。 三种关系指: 消费者-消费者 --...

sdoyuxuan
2017/06/07
0
0
Java实现生产者-消费者模型

考查Java的并发编程时,手写“生产者-消费者模型”是一个经典问题。有如下几个考点: 对Java并发模型的理解 对Java并发编程接口的熟练程度 bug free coding style JDK版本:oracle java 1.8...

猴子007
2017/10/16
0
0
RocketMQ实战(二)

在上一篇《RocketMQ实战(一)》中已经为大家初步介绍了下RocketMQ以及搭建了双Master环境,接下来继续为大家介绍! Quick Start 写一个简单的生产者、消费者,带大家快速体验RocketMQ~ Mav...

zfz_linux_boy
2017/04/17
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Win10内部更新:警告用户别用chrome和Firefox

简评:别和 Chrome 和 Firefox 约行不,我 Edge 明明更美、屁股更翘、更性感。。。 微软正在测试 Windows 10 的一个更新:警告用户不要安装 Chrome 和 Firefox。是测试人员发现的这个新警告,...

极光推送
37分钟前
2
0
Java并发编程高阶技术 高性能并发框架源码解析与实战

全网唯一深度解析并发编程框架disruptor底层源码课程,助你成为并发编程高手,拿下高薪 网盘地址下载

qq__2304636824
今天
1
0
day92-20180918-英语流利阅读-待学习

健身最大的敌人不是懒惰,而是逞强 Daniel 2018-09-19 1.今日导读 还记得 2008 年北京奥运会运动员刘翔的退赛风波吗?那天几乎所有中国人都将视线聚焦在了鸟巢体育馆 110 米栏的项目上,迫不...

飞鱼说编程
今天
8
0
70.shell的函数 数组 告警系统需求分析

20.16/20.17 shell中的函数 20.18 shell中的数组 20.19 告警系统需求分析 20.16/20.17 shell中的函数: ~1. 函数就是把一段代码整理到了一个小单元中,并给这个小单元起一个名字,当用到这段...

王鑫linux
今天
3
0
分布式框架spring-session实现session一致性使用问题

前言:项目中使用到spring-session来缓存用户信息,保证服务之间session一致性,但是获取session信息为什么不能再服务层获取? 一、spring-session实现session一致性方式 用户每一次请求都会...

WALK_MAN
今天
7
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部