JAVA并发实现五(生产者和消费者模式Condition方式实现)

package com.subject01;

import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),
 * 使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。
	Condition是个接口,基本的方法就是await()和signal()方法;
	Condition依赖于Lock接口,生成一个Condition的基本代码是lock.newCondition()
	 调用Condition的await()和signal()方法,都必须在lock保护之内,就是说必须在lock.lock()和lock.unlock之间才可以使用
	Conditon中的await()对应Object的wait();

  Condition中的signal()对应Object的notify();

  Condition中的signalAll()对应Object的notifyAll()。
 * @author 孙涛
 * 2016年5月12日
 */
public class CustormerAndProducterByCondition {

	private int queueSize = 10 ;
	private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);

	private Lock lock = new ReentrantLock();
	private Condition full = lock.newCondition();
	private Condition empty = lock.newCondition();

	class Consumer implements Runnable{

		@Override
		public void run() {
			consume();
		}
		/**
		 * 消费者
		 * @author suntao
		 * 2016年5月12日
		 */
		private void consume() {
			while(true){
				lock.lock();
				try {
					while(queue.size() == 0){
						try {
							System.out.println("队列空,等待数据");
							empty.await();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					queue.poll();
					full.signal();
					System.out.println("从队列取走一个元素,队列剩余"+queue.size()+"个元素");
				} finally{
					lock.unlock();
				}
			}

		}
	}
	/**
	 * 消费者
	 * @author 孙涛
	 * 2016年5月12日
	 */
	class Producer implements Runnable{

		@Override
		public void run() {
			produce();
		}

		private void produce() {
			while(true){
				lock.lock();
				try {
					while(queue.size()== queueSize){
						try {
							System.out.println("队列满,等待有空余空间");
							full.await();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					queue.offer(1);
					empty.signal();
				} finally{
					lock.unlock();
				}
			}
		}

	}

	public static void main(String[] args) {
		CustormerAndProducterByCondition cap = new CustormerAndProducterByCondition();
		Consumer cus = cap.new Consumer();
		Producer pro = cap.new Producer();
		Thread cusT = new Thread(cus);
		Thread proT = new Thread(pro);

		proT.start();
		cusT.start();
	}
}

 http://www.cnblogs.com/dolphin0520/p/3920385.html 

时间: 2024-10-07 05:12:03

JAVA并发实现五(生产者和消费者模式Condition方式实现)的相关文章

Java并发编程(4)--生产者与消费者模式介绍

一.前言 这种模式在生活是最常见的,那么它的场景是什么样的呢? 下面是我假象的,假设有一个仓库,仓库有一个生产者和一个消费者,消费者过来消费的时候会检测仓库中是否有库存,如果没有了则等待生产,如果有就先消费直至消费完成:而生产者每天的工作就是先检测仓库是否有库存,如果没有就开始生产,满仓了就停止生产等待消费,直至工作结束.下图是根据假象画的流程图: 那么在程序中怎么才能达到这样的效果呢?下面介绍三种方式实现. 二.使用notify() 和 wait()实现 相信大家这两个方法都不陌生,它是Obj

Java多线程设计模式(2)生产者与消费者模式

1 Producer-Consumer Pattern Producer-Consumer Pattern主要就是在生产者与消费者之间建立一个“桥梁参与者”,用来解决生产者线程与消费者线程之间速度的不匹配. 当要从某个线程Produccer参与者将数据传输给其它线程Consumer参与者的时候,此时就可以在中间加一个Channel参与者,在Channel参与者中以某种方式存放接受的数据,再以某方式来获取收到的数据,Channel就可以来缓存两个线程之间传输的数据,在Channel参与者为了保证安

同步函数 生产者和消费者模式 加强版(多人生产和多人消费)

曾经搞了半天, 生产者和消费者模式  加强版(多人生产 多人消费 ).. 以前的代码格式就不再吐槽了(以后努力改进) //输出结果是一个无限循环 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 多个生产者&多个消费者模式 * 多个生产者不断生产,多个消费者不停的消费

多线程生产者、消费者模式中,如何停止消费者?多生产者情况下对“毒丸”策略的应用。

生产者.消费者模式是多线程中的经典问题.通过中间的缓冲队列,使得生产者和消费者的速度可以相互调节. 对于比较常见的单生产者.多消费者的情况,主要有以下两种策略: 通过volatile boolean producerDone =false 来标示是否完成.生产者结束后标示为true, 消费者轮询这个变量来决定自己是否退出. 这种方式对producerDone产生比较大的争用,实现起来也有诸多问题需要考虑. 比较经典的"毒丸"策略,生产者结束后,把一个特别的对象:"毒丸&quo

实现生产者与消费者模式

实现生产者与消费者模式 目录 生产者与消费者模式 实现 生产者与消费者模式 什么是生产者消费者模式 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题.生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力. 这个阻塞队列就是用来给生产者和消费者解耦的.纵观大多数设计模式,都会找一个第三者出来进行解耦,如工厂模式

Linux:生产者与消费者模式

生产者:生产数据 消费者:消费数据 提供场所:缓冲区,eg:超市 生产者消费者特点:三种关系,两类人,一个场所 三种关系指的是:生产者与生产者之间是互斥关系 消费者与消费者之间是互斥关系 生产者与消费者之间是同步与互斥关系 两类人:生产者,消费者 一个场所:存储数据(此处用带头单链表实现) 单生产者单消费者模式:此例取数据方式为FIFO先进先出. 利用互斥锁实现单生产者单消费者模式. #include<stdio.h> #include<malloc.h> #include<

生产者与消费者模式(线程的同步与互斥)

死锁产生的四个条件: 1.互斥使用(资源独占) 一个资源每次只能给一个进程使用 .2.不可强占(不可剥夺) 资源申请者不能强行的从资源占有者手中夺取资源,资源只能由占有者自愿释放 .3.请求和保持(部分分配,占有申请) 一个进程在申请新的资源的同时保持对原有资源的占有(只有这样才是动态申请,动态分配) .4.循环等待 存在一个进程等待队列 {P1 , P2 , - , Pn}, 其中P1等待P2占有的资源,P2等待P3占有的资源,-,Pn等待P1占有的资源,形成一个进程等待环路 生产者:生产数据

python实现生产者和消费者模式

利用python的线程实现简单生产者和消费者模式,这种模式在多线程编程时还是用的比较多吧,下面是源代码: 1 #!/usr/bin/python 2 # -*- coding: utf-8 -*- 3 import requests,time 4 import threading,queue 5 6 7 class mythread_1(threading.Thread): 8 def __init__(self,queue): 9 super(mythread_1,self).__init__

python 生产者与消费者模式

生产者与消费者模式 1. 队列 先进先出 2. 栈 先进后出 Python的Queue模块中提供了同步的.线程安全的队列类,包括FIFO(先入先出)队列Queue,LIFO(后入先出)队列LifoQueue,和优先级队列PriorityQueue.这些队列都实现了锁原语(可以理解为原子操作,即要么不做,要么就做完),能够在多线程中直接使用.可以使用队列来实现线程间的同步. 用FIFO队列实现上述生产者与消费者问题的代码如下: import threading import time from q