生产者消费者模式的三种实现方式

原作者：老铁123　　　
出处：https://blog.csdn.net/qewgd/article/details/85926275　　　
本文归作者【老铁123】和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

生产者消费者模式
1、生产者只在仓库未满时进行生产，仓库满时生产者进程被阻塞；
2、消费者只在仓库非空时进行消费，仓库为空时消费者进程被阻塞；

一、synchronized方式实现
代码如下

**ProduceAndConsumeBySynchronized.java**
public class ProduceAndConsumeBySynchronized{
// TODO多线程调用
}

class StoreWN {
public int capacity = 10;
public int index = 0;

public synchronized void produce() {
while (index >= capacity) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
index++;
notifyAll();
}

public synchronized void consume() {
while (index <= 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
index--;
notifyAll();
}
}

class Producer implements Runnable {
StoreWN swn = null;

public Producer(StoreWN swn) {
this.swn = swn;
}

public void run() {
swn.produce();
}
}

class Consumer implements Runnable {
StoreWN swn = null;

public Consumer(StoreWN swn) {
this.swn = swn;
}

public void run() {
swn.consume();
}
}

二、Lock API方式实现
代码如下

**ProduceAndConsumeByLockApi.java**

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProduceAndConsumeByLockApi {
// TODO多线程调用
}

class StoreAS {
public int capacity = 10;
public int index = 0;
Lock lock = new ReentrantLock();
Condition full = lock.newCondition();
Condition empty = lock.newCondition();

public void produce() {
lock.lock();
try {
while (index >= capacity) {
try {
full.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
index++;
empty.signalAll();
} finally {
lock.unlock();
}
}

public void consume() {
lock.lock();
try {
while (index <= capacity) {
try {
empty.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
index--;
full.signalAll();
} finally {
lock.unlock();
}
}
}

class ProducerAS implements Runnable {
StoreAS swn = null;

public ProducerAS(StoreAS swn) {
this.swn = swn;
}

public void run() {
swn.produce();
}
}

class ConsumerAS implements Runnable {
StoreAS swn = null;

public ConsumerAS(StoreAS swn) {
this.swn = swn;
}

public void run() {
swn.consume();
}
}

三、阻塞队列方式实现(底层就是实现方式二)
代码如下

**ProduceAndConsumeByBlockingQueue.java**

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProduceAndConsumeByBlockingQueue {
// TODO多线程调用
}

class StoreBQ {
BlockingQueue<Integer> bq = new ArrayBlockingQueue<Integer>(10);

public void produce(){
try {
bq.put(1);
} catch (InterruptedException e) {
}
}

public void consume(){
try {
bq.take();
} catch (InterruptedException e) {
}
}
}

class ProducerBQ implements Runnable {
StoreBQ swn = null;

public ProducerBQ(StoreBQ swn) {
this.swn = swn;
}

public void run() {
swn.produce();
}
}

class ConsumerBQ implements Runnable {
StoreBQ swn = null;

public ConsumerBQ(StoreBQ swn) {
this.swn = swn;
}

public void run() {
swn.consume();
}
}