文档章节

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

特拉仔
 特拉仔
发布于 2017/06/02 09:54
字数 706
阅读 5
收藏 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列表数据类型实现

    因为它具有可阻塞特性。

    代码待补充

© 著作权归作者所有

共有 人打赏支持
特拉仔
粉丝 38
博文 189
码字总数 168554
作品 0
渝中
高级程序员
私信 提问
springboot rabbitmq整合

转载:https://www.cnblogs.com/xmzJava/p/8036591.html 这一篇我们来把消息中间件整合到springboot中 ===================================================================== 首先在服务器......

一支支穿云箭
09/28
0
0
[高并发Java 七] 并发设计模式

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

Hosee
2016/02/14
6.7K
0
Java实现生产者-消费者模型

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

monkeysayhi
2017/11/20
0
0
Java实现生产者-消费者模型

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

猴子007
2017/10/16
0
0
Linux 下多线程的消费者-生产者模型

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

sdoyuxuan
2017/06/07
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Go 使用channel控制并发

前言 channel一般用于协程之间的通信,channel也可以用于并发控制。比如主协程启动N个子协程,主协程等待所有子协程退出后再继续后续流程,这种场景下channel也可轻易实现。 场景示例 总结 ...

恋恋美食
31分钟前
1
0
Apache Flink 漫谈系列 - 持续查询(Continuous Queries)

摘要: 实际问题 我们知道在流计算场景中,数据是源源不断的流入的,数据流永远不会结束,那么计算就永远不会结束,如果计算永远不会结束的话,那么计算结果何时输出呢?本篇将介绍Apache Fl...

阿里云官方博客
35分钟前
6
0
斐波那契堆的理解,节点mark属性和势函数

斐波那契堆 看了好多博客,都是照搬算法导论的内容,没有自己的理解,比如为什么有mark属性,势函数的作用,以及为什么叫斐波那契堆,下面说说鄙人的理解。 势函数 势函数是根节点个数加上2...

杨喆
36分钟前
3
0
NIO源码详解

阻塞io和无阻塞io: 阻塞io是指jdk1.4之前版本面向流的io,服务端需要对每个请求建立一堆线程等待请求,而客户端发送请求后,先咨询服务端是否有线程相应,如果没有则会一直等待或者遭到拒 ...

沉稳2018
40分钟前
0
0
如何把已经提交的commit, 从一个分支放到另一个分支

在本地master提交了一个commit(8d85d4bca680a5dbcc3e5cfb3096d18cd510cc9f),如何提交的test_2分之上? git checkout test_2git cherry-pick 8d85d4bca680a5dbcc3e5cfb3096d18cd510cc9f......

stephen_wu
44分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部