java实现生产消费者模式,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());

//Storage storage = new LockStorage(5, new LinkedList());

//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 products;

private int MAX = 10;

public BlockStorage(int max){

products = new LinkedBlockingQueue(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 products = new LinkedList<>();

private int MAX = 10;

public LockStorage(int max,LinkedList 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 products = new LinkedList<>();

private int MAX = 10;

public LinkedStorage(int max,LinkedList 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();

}

}

}