java实现生产者消费者问题

引言

　　生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，如下图所示，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况：

生产者消费者图

　　存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁。

JAVA解决线程模型的三种方式

　　1、wait()和notify()

按 Ctrl+C 复制代码

import java.util.LinkedList;public class ProducerConsumer { private LinkedList<Object> storeHouse = new LinkedList<Object>(); private int MAX = 10; public ProducerConsumer() { } public void start() { new Producer().start(); new Comsumer().start(); } class Producer extends Thread { public void run() { while (true) { synchronized (storeHouse) { try { while (storeHouse.size() == MAX) { System.out.println("storeHouse is full , please wait"); storeHouse.wait(); } Object newOb = new Object(); if (storeHouse.add(newOb)) { System.out.println("Producer put a Object to storeHouse"); Thread.sleep((long) (Math.random() * 3000)); storeHouse.notify(); } } catch (InterruptedException ie) { System.out.println("producer is interrupted!"); } } } } } class Comsumer extends Thread { public void run() { while (true) { synchronized (storeHouse) { try { while (storeHouse.size() == 0) { System.out.println("storeHouse is empty , please wait"); storeHouse.wait(); } storeHouse.removeLast(); System.out.println("Comsumer get a Object from storeHouse"); Thread.sleep((long) (Math.random() * 3000)); storeHouse.notify(); } catch (InterruptedException ie) { System.out.println("Consumer is interrupted"); } } } } } public static void main(String[] args) throws Exception { ProducerConsumer pc = new ProducerConsumer(); pc.start(); }}

按 Ctrl+C 复制代码

 

　　2、await()和signal()，即线程锁的方式

package sort;import java.util.LinkedList;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class ProducerConsumer {    private LinkedList<Object> myList = new LinkedList<Object>();    private int MAX = 10;    private final Lock lock = new ReentrantLock();    private final Condition full = lock.newCondition();    private final Condition empty = lock.newCondition();    public ProducerConsumer() {    }    public void start() {        new Producer().start();        new Consumer().start();    }    public static void main(String[] args) throws Exception {        ProducerConsumer s2 = new ProducerConsumer();        s2.start();    }    class Producer extends Thread {        public void run() {            while (true) {                lock.lock();                try {                    while (myList.size() == MAX) {                        System.out.println("warning: it's full!");                        full.await();                    }                    Object o = new Object();                    if (myList.add(o)) {                        System.out.println("Producer: " + o);                        empty.signal();                    }                } catch (InterruptedException ie) {                    System.out.println("producer is interrupted!");                } finally {                    lock.unlock();                }            }        }    }    class Consumer extends Thread {        public void run() {            while (true) {                lock.lock();                try {                    while (myList.size() == 0) {                        System.out.println("warning: it's empty!");                        empty.await();                    }                    Object o = myList.removeLast();                    System.out.println("Consumer: " + o);                    full.signal();                } catch (InterruptedException ie) {                    System.out.println("consumer is interrupted!");                } finally {                    lock.unlock();                }            }        }    }}

 

　　3、阻塞队列的方式

import java.util.concurrent.*;public class ProducerConsumer {    // 建立一个阻塞队列    private LinkedBlockingQueue<Object> queue = new LinkedBlockingQueue<Object>(10);    public ProducerConsumer() {    }    public void start() {        new Producer().start();        new Consumer().start();    }    public static void main(String[] args) throws Exception {        ProducerConsumer s3 = new ProducerConsumer();        s3.start();    }    class Producer extends Thread {        public void run() {            while (true) {                try {                    Object o = new Object();                    // 取出一个对象                    queue.put(o);                    System.out.println("Producer: " + o);                } catch (InterruptedException e) {                    System.out.println("producer is interrupted!");                }                // }            }        }    }    class Consumer extends Thread {        public void run() {            while (true) {                try {                    // 取出一个对象                    Object o = queue.take();                    System.out.println("Consumer: " + o);                } catch (InterruptedException e) {                    System.out.println("producer is interrupted!");                }                // }            }        }    }}

结论

  三种方式原理一致，都是对独占空间加锁，阻塞和唤醒线程，第一种方式比较传统，第三种方式最简单，只需存储和取用，线程同步的操作交由LinkedBlockingQueue全权处理。

转载自：http://www.cnblogs.com/happyPawpaw/archive/2013/01/18/2865957.html