文档章节

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

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

    因为它具有可阻塞特性。

    代码待补充

© 著作权归作者所有

共有 人打赏支持
特拉仔
粉丝 25
博文 178
码字总数 162534
作品 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
生产者/消费者问题的多种Java实现方式

生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两...

HenrySun
2016/05/04
89
0
架构设计:生产者/消费者模式 第3页:队列缓冲区

[2]:队列缓冲区 经过前面两个帖子的铺垫,今天终于开始聊一些具体的编程技术了。由于不同的缓冲区类型、不同的并发场景对于具体的技术实现有较大的影响。为了深入浅出、便 于大伙儿理解,咱...

冰雷卡尔
2014/05/06
84
0
关于Java多线程的一些常考知识点

前言 多线程也是面试中经常会提起到的一个点。面试官会问:实现多线程的两种方式以及区别,死锁发生的个条件以及如何避免发生死锁,死锁和活锁的区别,常见的线程池以及区别,怎么理解有界队...

cmazxiaoma
2017/12/11
0
0
并发容器与框架——并发容器(二)

1.何为阻塞队列 阻塞队列(BlockingQueue)是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。 支持阻塞的插入方法:意思是当队列满(无界队列除外)时,队列会阻塞...

江左煤郎
05/06
0
0
RabbitMQ与消息队列模式

MQ全称为Message Queue,消息队列是应用程序和应用程序之间的通信方法; RabbitMQ是开源的,实现了AMQP协议的,采用Erlang(面向并发编程语言)编写的,可复用的企业级消息系统; AMQP(高级消...

Java技术汇
05/15
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

about git flow

  昨天元芳做了git分支管理规范的分享,为了拓展大家关于git分支的认知,这里我特意再分享这两个关于git flow的链接,大家可以看一下。 Git 工作流程 Git分支管理策略   git flow本质上是...

qwfys
今天
2
0
Linux系统日志文件

/var/log/messages linux系统总日志 /etc/logrotate.conf 日志切割配置文件 参考https://my.oschina.net/u/2000675/blog/908189 dmesg命令 dmesg’命令显示linux内核的环形缓冲区信息,我们可...

chencheng-linux
今天
1
0
MacOS下给树莓派安装Raspbian系统

下载镜像 前往 树莓派官网 下载镜像。 点击 最新版Raspbian 下载最新版镜像。 下载后请,通过 访达 双击解压,或通过 unzip 命令解压。 检查下载的文件 ls -lh -rw-r--r-- 1 dingdayu s...

dingdayu
今天
1
0
spring boot使用通用mapper(tk.mapper) ,id自增和回显等问题

最近项目使用到tk.mapper设置id自增,数据库是mysql。在使用通用mapper主键生成过程中有一些问题,在总结一下。 1、UUID生成方式-字符串主键 在主键上增加注解 @Id @GeneratedValue...

北岩
今天
2
0
告警系统邮件引擎、运行告警系统

告警系统邮件引擎 cd mail vim mail.py #!/usr/bin/env python#-*- coding: UTF-8 -*-import os,sysreload(sys)sys.setdefaultencoding('utf8')import getoptimport smtplibfr......

Zhouliang6
今天
1
0
Java工具类—随机数

Java中常用的生成随机数有Math.random()方法及java.util.Random类.但他们生成的随机数都是伪随机的. Math.radom()方法 在jdk1.8的Math类中可以看到,Math.random()方法实际上就是调用Random类...

PrivateO2
今天
2
0
关于java内存模型、并发编程的好文

Java并发编程:volatile关键字解析    volatile这个关键字可能很多朋友都听说过,或许也都用过。在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果。在...

DannyCoder
昨天
1
0
dubbo @Reference retries 重试次数 一个坑

在代码一中设置 成retries=0,也就是调用超时不用重试,结果DEBUG的时候总是重试,不是0吗,0就不用重试啊。为什么还是调用了多次呢? 结果在网上看到 这篇文章才明白 https://www.cnblogs....

奋斗的小牛
昨天
2
0
数据结构与算法3

要抓紧喽~~~~~~~放羊的孩纸回来喽 LowArray类和LowArrayApp类 程序将一个普通的Java数组封装在LowArray类中。类中的数组隐藏了起来,它是私有的,所以只有类自己的方法才能访问他。 LowArray...

沉迷于编程的小菜菜
昨天
1
0
spring boot应用测试框架介绍

一、spring boot应用测试存在的问题 官方提供的测试框架spring-boot-test-starter,虽然提供了很多功能(junit、spring test、assertj、hamcrest、mockito、jsonassert、jsonpath),但是在数...

yangjianzhou
昨天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部