生产者消费者实例

生产者消费者实例

代码参考了： http://blog.csdn.net/monkey_d_meng/article/details/6251879/
并在此基础上做了改动

• 用wait()、notify()、notifyAll()方法写（在代码中被注释了）。
• 用Lock、ReentrantLock、await()、signalAll()写

类图如下：

代码如下：

import java.util.LinkedList;

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


abstract class People { // 增加了一个抽象类
    int num = 0;
    public void produce(int num){}
    public void consume(int num){}

    public void setNum(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}


class Producer extends People implements Runnable {
    private Storage storage;

    public Producer(Storage storage) {  
        this.storage = storage;  
    }  

    @Override
    public void produce(int num) {
        storage.produce(num);
    }

    @Override
    public void run() {
        produce(num);
    }
}


class Consumer extends People implements Runnable { // 改用Runnable接口
    private Storage storage;

    public Consumer(Storage storage) {  
        this.storage = storage;  
    } 

    @Override
    public void consume(int num) {
        storage.consume(num);
    }

    @Override
    public void run() {
        consume(num);
    }
}


public class Storage {

    private final int MAX_SIZE = 100; // 仓库的最大存储量
    private LinkedList<Object> list = new LinkedList();

    private final Lock lock = new ReentrantLock();
    private final Condition full = lock.newCondition();
    private final Condition empty = lock.newCondition();


    public void produce(int num) { // 生产num个产品
//      synchronized(list) { // 同步代码块

        lock.lock();

            while(list.size() + num > MAX_SIZE) { // 如果仓库剩余容量不足
                System.out.println("【要生产的产品数量】：" + num + " 【库存量】：" 
                         + list.size() + "  暂时不能执行生产任务");
                try{
//                  list.wait();
                    full.await();
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for(int i = 0; i < num; i++) {
                list.add(new Object());
            }
            System.out.println("【已经生产产品数】：" + num + " 【现仓储量为】:" + list.size());
//          list.notifyAll();

        full.signalAll();
        empty.signalAll();
        lock.unlock();
//      }
    }

    public void consume(int num) { // 消费num个产品
//      synchronized(list) {
        lock.lock();
            while(list.size() < num) {
                System.out.println("【要消费的产品数量】:" + num + " 【库存量】:"  
                        + list.size() + " 暂时不能执行消费任务!");
                try {
//                  list.wait();
                    empty.await();
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for(int i = 0; i < num; i++) {
                list.remove();
            }
            System.out.println("【已经消费产品数】:" + num + " 【现仓储量为】:" + list.size());
//          list.notifyAll();

        full.signalAll();
        empty.signalAll();
        lock.unlock();
//      }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // 仓库对象  
        Storage storage = new Storage();  

        // 生产者对象  
        Producer p1 = new Producer(storage);  
        Producer p2 = new Producer(storage);  
        Producer p3 = new Producer(storage);  
        Producer p4 = new Producer(storage);  
        Producer p5 = new Producer(storage);  
        Producer p6 = new Producer(storage);  
        Producer p7 = new Producer(storage);  

        // 消费者对象  
        Consumer c1 = new Consumer(storage);  
        Consumer c2 = new Consumer(storage);  
        Consumer c3 = new Consumer(storage);  

        // 设置生产者产品生产数量  
        p1.setNum(60);  
        p2.setNum(70);  
        p3.setNum(80);  
        p4.setNum(10);  
        p5.setNum(10);  
        p6.setNum(10);  
        p7.setNum(80);  

        // 设置消费者产品消费数量  
        c1.setNum(50);  
        c2.setNum(20);  
        c3.setNum(30);  

        // 线程开始执行  
        new Thread(c1, "c1").start();
        new Thread(c2, "c2").start();
        new Thread(c3, "c3").start();

        new Thread(p1, "p1").start();
        new Thread(p2, "p2").start();
        new Thread(p3, "p3").start();
        new Thread(p4, "p4").start();
        new Thread(p5, "p5").start();
        new Thread(p6, "p6").start();
        new Thread(p7, "p7").start();

    }

}