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

使用Java实现生产者和消费者模式。

package part4;

import java.util.LinkedList;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 生产者消费者模式的三种实现方式
 * @author Administrator
 *
 */
public class ProduceAndConsumer {
	public static void main(String[] args) {
		Storage storage = new LinkedStorage(10, new LinkedList<Object>());
		//Storage storage = new LockStorage(5, new LinkedList<Object>());
		//Storage storage = new BlockStorage(5);


		//创建多个生成者线程
		Thread produce = new Thread(new Produce(storage),"produce");
		Thread produce1 = new Thread(new Produce(storage),"produce1");
		Thread produce2 = new Thread(new Produce(storage),"produce2");
		Thread produce3 = new Thread(new Produce(storage),"produce3");
		Thread produce4 = new Thread(new Produce(storage),"produce4");
		
		//创建消费者线程
		Thread consumerNew = new Thread(new ConsumerNew(storage),"consumerNew");
		
		produce.start();
		produce1.start();
		produce2.start();
		produce3.start();
		produce4.start();
		consumerNew.start();
	}
}

/**
 * 仓库接口
 * 模拟产品的生成、消费
 * @author Administrator
 *
 */
interface Storage{
	void put(Object obj);
	void get();
}

/**
 * 通过block方式实现生产者和消费者模式
 * @author Administrator
 *
 */
class BlockStorage implements Storage{

	private LinkedBlockingQueue<Object> products;
	private int MAX = 10;
	
	public BlockStorage(int max){
		products = new LinkedBlockingQueue<Object>(max);
		this.MAX = max;
	}
	@Override
	public void put(Object obj) {
		if (this.products.size() >= MAX) {
			System.out.println("BlockStorage products full! please wait!");
		}
		try {
			products.put(obj);
			System.out.println(Thread.currentThread().getName()+" BlockStorage put obj:" + obj+"  size:"+products.size());
			//生产者线程睡眠3秒
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void get() {
		if (this.products.isEmpty()) {
			System.out.println("BlockStorage products empty! please wait!");
		}
		try {
			System.out.println("BlockStorage get obj::" + products.take()
					+ "  size::" + products.size());
			//消费者睡眠1秒
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
	
}

/**
 * 用锁实现生产者和消费者模式
 * @author Administrator
 *
 */
class LockStorage implements Storage{

	private Lock lock = new ReentrantLock();
	private Condition full = lock.newCondition();
	private Condition empty = lock.newCondition();
	
	/**
	 * 产品列表
	 */
	private LinkedList<Object> products = new LinkedList<>();
	private int MAX = 10;
	
	public LockStorage(int max,LinkedList<Object> products){
		this.MAX = max;
		this.products = products;
	}
	
	
	@Override
	public void put(Object obj) {
		lock.lock();
		try{
			if (this.products.size() >= MAX) {
				System.out.println("LockStorage products full! please wait!");
				full.await();
			}
			products.add(obj);
			System.out.println(Thread.currentThread().getName()+" LockStorage put obj:" + obj+"  size:"+products.size());
			TimeUnit.SECONDS.sleep(3);
			
			// 唤醒其他所有线程 
			full.signalAll();
	        empty.signalAll();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}

	@Override
	public void get() {
		lock.lock();
		try{
			if (this.products.isEmpty()) {
				System.out.println("LockStorage products empty! please wait!");
				empty.await();
			}
			System.out.println("LockStorage get obj::" + products.removeLast()
					+ "  size::" + products.size());
			TimeUnit.SECONDS.sleep(2);
			
			
			// 唤醒其他所有线程
			full.signalAll();
			empty.signalAll();
		}catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
}

/**
 * 使用Synchronized关键字实现生产者和消费者模式
 * @author Administrator
 *
 */
class LinkedStorage implements Storage{
	/**
	 * 产品列表
	 */
	private LinkedList<Object> products = new LinkedList<>();
	private int MAX = 10;
	
	public LinkedStorage(int max,LinkedList<Object> products){
		this.MAX = max;
		this.products = products;
	}
	
	public void put(Object obj){
		synchronized (products) {
			try {
				if (this.products.size() >= MAX) {
					System.out.println("products full! please wait!");
					//将当前线程挂起
					products.wait();
				}
				products.add(obj);
				System.out.println(Thread.currentThread().getName()+" put obj:" + obj+"  size:"+products.size());
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				System.out.println("put interrupted!");
				e.printStackTrace();
			}
			//通知其他线程
			products.notify();
		}
	}
	
	public void get(){
		synchronized (products) {
			try {
				if (this.products.isEmpty()) {
					System.out.println("products empty! please wait!");
					products.wait();
				}
				System.out.println("get obj::" + products.removeLast()
						+ "  size::" + products.size());
				TimeUnit.SECONDS.sleep(2);
				products.notify();
			} catch (InterruptedException e) {
				System.out.println("get interrupted!");
				e.printStackTrace();
			}
		}
	}
}

class Produce implements Runnable{
	private Storage storage;
	private volatile int i = 0;
	
	public Produce(Storage storage){
		this.storage = storage;
	}

	@Override
	public void run() {
		while(true){
			storage.put(i++);
		}
	}
}

class ConsumerNew implements Runnable{
	private Storage storage;
	
	public ConsumerNew(Storage storage){
		this.storage = storage;
	}

	@Override
	public void run() {
		while(true){
			storage.get();
		}
	}
}

转载于:https://my.oschina.net/u/575836/blog/793655