利用多线程实现生产者-消费者

public class WorkshopService {
    private int buffer[]=null;
    //反映缓冲区当前的大小
    private int size=0;
    private static final Lock lock = new ReentrantLock();
    private static final Condition ProCondition = lock.newCondition();//用于锁定生产者
    private static final Condition ConCondition = lock.newCondition();//用于锁定消费者
    
    public WorkshopService(int capacity) {

        this.buffer=new int[capacity];
    }
    
    //同步方法，同一时刻只允许有一个生产者或消费者线程进入该方法
    public void put(int elem) throws InterruptedException {

        lock.lock();
        /*
        若没有空位，则等待
        此处必须写成while,不能是if；如果是if，线程被唤醒并且获得锁之后
        会直接执行后面的语句,可能发生数组越界异常
        注1
         */
        while(size>=buffer.length)
            ProCondition.await();
        
        buffer[size]=elem;
        size++;
        //唤醒一个消费者线程
        ConCondition.signal();
        lock.unlock();
    }
    
    public int take() throws InterruptedException{

        lock.lock();
        //若没有产品则等待
        while(size<=0)
            ConCondition.await();
        
        int temp=buffer[size-1];
        size--;
        //唤醒一个生产者线程
        ProCondition.signal();
        lock.unlock();
        return temp;
    }
}

public class Producer extends Thread{
    
    private WorkshopService service=null;
    private static final Random r = new Random();

    
    public Producer(WorkshopService service) {
        this.service=service;
    }
    
    private int Producing() throws InterruptedException {
        //模拟生产活动
        System.out.println("好累啊");
        Thread.currentThread().sleep(1000);
        return r.nextInt(1000);
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            int product=Producing();
            service.put(product);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

public class Consumer extends Thread{
    
    WorkshopService service=null;
    
    public Consumer(WorkshopService service) {
        // TODO Auto-generated constructor stub
        this.service=service;
    }
    
    private void Consuming(int product) throws InterruptedException {
        System.out.println("垃圾产品");
        Thread.currentThread().sleep(1000);
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            int product=service.take();
            Consuming(product);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

public class Main {

    private static final int num = 10;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        WorkshopService service=new WorkshopService(30);
        Producer p[] = new Producer[num];
        Consumer c[] = new Consumer[num];
        
       for(int i=0;i<num;i++) {
        p[i]=new Producer(service);
        c[i]=new Consumer(service);
        p[i].start();
        c[i].start();
       }
    }
}