文档章节

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

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

    因为它具有可阻塞特性。

    代码待补充

© 著作权归作者所有

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

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

一支支穿云箭
2018/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

没有更多内容

加载失败,请刷新页面

加载更多

Cookie 显示用户上次访问的时间

import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.Cookie;import javax.servlet.http.HttpServlet;import javax.serv......

gwl_
51分钟前
1
0
网络编程

第14天 网络编程 今日内容介绍  网络通信协议  UDP通信  TCP通信 今日学习目标  能够辨别UDP和TCP协议特点  能够说出UDP协议下两个常用类名称  能够说出TCP协议下两个常用类名称...

stars永恒
今天
1
0
二进制相关

二进制 众所周知计算机使用的是二进制,数字的二进制是如何表示的呢? 实际就是逢二进一。比如 2 用二进制就是 10。那么根据此可以推算出 5的二进制等于 10*10+1 即为 101。 在计算机中,负数以...

NotFound403
昨天
3
0
day22:

1、写一个getinterface.sh 脚本可以接受选项[i,I],完成下面任务: 1)使用格式:getinterface.sh [-i interface | -I ip] 2)当用户使用-i选项时,显示指定网卡的IP地址;当用户使用-I选项...

芬野de博客
昨天
2
0
Spring Cloud Alibaba基础教程:使用Nacos实现服务注册与发现

自Spring Cloud Alibaba发布第一个Release以来,就备受国内开发者的高度关注。虽然Spring Cloud Alibaba还没能纳入Spring Cloud的主版本管理中,但是凭借阿里中间件团队的背景,还是得到不少...

程序猿DD
昨天
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部