生产者消费者 java实现_用Java实现生产者消费者的几种方法

一、采用synchronized锁以及wait notify方法实现

import java.io.IOException;

public class WaitAndNotify

{

public static void main(String[] args) throws IOException

{

Person person = new Person();

new Thread(new Consumer("消费者一", person)).start();

new Thread(new Consumer("消费者二", person)).start();

new Thread(new Consumer("消费者三", person)).start();

new Thread(new Producer("生产者一", person)).start();

new Thread(new Producer("生产者一", person)).start();

new Thread(new Producer("生产者一", person)).start();

}

}

class Producer implements Runnable

{

private Person person;

private String producerName;

public Producer(String producerName, Person person)

{

this.producerName = producerName;

this.person = person;

}

@Override

public void run()

{

while (true)

{

try

{

person.produce();

} catch (InterruptedException e)

{

e.printStackTrace();

}

}

}

}

class Consumer implements Runnable

{

private Person person;

private String consumerName;

public Consumer(String consumerName, Person person)

{

this.consumerName = consumerName;

this.person = person;

}

@Override

public void run()

{

try

{

person.consume();

} catch (InterruptedException e)

{

e.printStackTrace();

}

}

}

class Person

{

private int foodNum = 0;

private Object synObj = new Object();

private final int MAX_NUM = 5;

public void produce() throws InterruptedException

{

synchronized (synObj)

{

while (foodNum == 5)

{

System.out.println("box is full，size = " + foodNum);

synObj.wait();

}

foodNum++;

System.out.println("produce success foodNum = " + foodNum);

synObj.notifyAll();

}

}

public void consume() throws InterruptedException

{

synchronized (synObj)

{

while (foodNum == 0)

{

System.out.println("box is empty,size = " + foodNum);

synObj.wait();

}

foodNum--;

System.out.println("consume success foodNum = " + foodNum);

synObj.notifyAll();

}

}

}

二、采用Lock锁以及await和signal方法是实现

import java.io.IOException;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

/**

* @author 作者 E-mail:

* @version 创建时间：2015-10-23 下午04:08:39 类说明

*/

public class AwaitAndSignal

{

public static void main(String[] args) throws IOException

{

Person person = new Person();

new Thread(new Consumer(person), "消费者一").start();

new Thread(new Consumer(person), "消费者二").start();

new Thread(new Consumer(person), "消费者三").start();

new Thread(new Producer(person), "生产者一").start();

new Thread(new Producer(person), "生产者一").start();

new Thread(new Producer(person), "生产者一").start();

}

}

class Producer implements Runnable

{

private Person person;

public Producer(Person person)

{

this.person = person;

}

@Override

public void run()

{

for (int i = 0; i < 10; i++)

{

person.produce();

}

}

}

class Consumer implements Runnable

{

private Person person;

public Consumer(Person person)

{

this.person = person;

}

@Override

public void run()

{

for (int i = 0; i < 10; i++)

{

person.consume();

}

}

}

class Person

{

private int foodNum = 0;

private ReentrantLock lock = new ReentrantLock();

private Condition condition = lock.newCondition();

private final int MAX_NUM = 5;

public void produce()

{

lock.lock();

try

{

while (foodNum == MAX_NUM)

{

System.out.println("box is full，size = " + foodNum);

condition.await();

}

foodNum++;

System.out.println("produce success foodNum = " + foodNum);

condition.signalAll();

}

catch(InterruptedException e)

{

e.printStackTrace();

} finally

{

lock.unlock();

}

}

public void consume()

{

lock.lock();

try

{

while (foodNum == 0)

{

System.out.println("box is empty,size = " + foodNum);

condition.await();

}

foodNum--;

System.out.println("consume success foodNum = " + foodNum);

condition.signalAll();

}

catch(InterruptedException e)

{

e.printStackTrace();

} finally

{

lock.unlock();

}

}

}

三、采用BlockingQueue实现

BlockingQueue也是java.util.concurrent下的主要用来控制线程同步的工具。

BlockingQueue有四个具体的实现类,根据不同需求,选择不同的实现类

1、ArrayBlockingQueue：一个由数组支持的有界阻塞队列，规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的。

2、LinkedBlockingQueue：大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出)顺序排序的。

3、PriorityBlockingQueue：类似于LinkedBlockQueue,但其所含对象的排序不是FIFO,而是依据对象的自然排序顺序或者是构造函数的Comparator决定的顺序。

4、SynchronousQueue：特殊的BlockingQueue,对其的操作必须是放和取交替完成的。

LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的话，默认最大是Integer.MAX_VALUE,其中主要用到put和take方法，put方法在队列满的时候会阻塞直到有队列成员被消费，take方法在队列空的时候会阻塞，直到有队列成员被放进来。

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {

BlockingQueue queue;

public Producer(BlockingQueue queue) {

this.queue = queue;

}

@Override

public void run() {

try {

String temp = "A Product, 生产线程："

+ Thread.currentThread().getName();

System.out.println("I have made a product:"

+ Thread.currentThread().getName());

queue.put(temp);//如果队列是满的话，会阻塞当前线程

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable{

BlockingQueue queue;

public Consumer(BlockingQueue queue){

this.queue = queue;

}

@Override

public void run() {

try {

String temp = queue.take();//如果队列为空，会阻塞当前线程

System.out.println(temp);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

public class Test3 {

public static void main(String[] args) {

BlockingQueue queue = new LinkedBlockingQueue(2);

// BlockingQueue queue = new LinkedBlockingQueue();

//不设置的话，LinkedBlockingQueue默认大小为Integer.MAX_VALUE

// BlockingQueue queue = new ArrayBlockingQueue(2);

Consumer consumer = new Consumer(queue);

Producer producer = new Producer(queue);

for (int i = 0; i < 5; i++) {

new Thread(producer, "Producer" + (i + 1)).start();

new Thread(consumer, "Consumer" + (i + 1)).start();

}

}

}BlockingQueue接口，扩展了Queue接口

package java.util.concurrent;

import java.util.Collection;

import java.util.Queue;

public interface BlockingQueue extends Queue {

boolean add(E e);

boolean offer(E e);

void put(E e) throws InterruptedException;

boolean offer(E e, long timeout, TimeUnit unit)

throws InterruptedException;

E take() throws InterruptedException;

E poll(long timeout, TimeUnit unit)

throws InterruptedException;

int remainingCapacity();

boolean remove(Object o);

public boolean contains(Object o);

int drainTo(Collection super E> c);

int drainTo(Collection super E> c, int maxElements);

}

我们用到的take() 和put(E e)

两个方法，在ArrayBlockingQueue中的实现

public void put(E e) throws InterruptedException {

if (e == null) throw new NullPointerException();

final E[] items = this.items;

final ReentrantLock lock = this.lock;

lock.lockInterruptibly();

try {

try {

while (count == items.length)

notFull.await();

} catch (InterruptedException ie) {

notFull.signal(); // propagate to non-interrupted thread

throw ie;

}

insert(e);

} finally {

lock.unlock();

}

}

private void insert(E x) {

items[putIndex] = x;

putIndex = inc(putIndex);

++count;

notEmpty.signal();

}

public E take() throws InterruptedException {

final ReentrantLock lock = this.lock;

lock.lockInterruptibly();

try {

try {

while (count == 0)

notEmpty.await();

} catch (InterruptedException ie) {

notEmpty.signal(); // propagate to non-interrupted thread

throw ie;

}

E x = extract();

return x;

} finally {

lock.unlock();

}

}

private E extract() {

final E[] items = this.items;

E x = items[takeIndex];

items[takeIndex] = null;

takeIndex = inc(takeIndex);

--count;

notFull.signal();

return x;

}

看得到其实也是利用了Lock以及Condition条件变量的await()方法和signal()方法实现的，这个实现和我们之前实现的Lock用法区别：

1)使用了两个条件变量 consume的await放置在notEmpty 之上，唤醒在put的时候，produce的await放置在notfull之上，唤醒在take()的时候，唤醒是signal而不是signalAll，这样做就不会因为大量唤醒导致竞争从而减低效率，通过锁对象的分析，减低竞争

优点：更有利于协调生产消费线程的平衡