多生产者 多消费者

实现连续生产多个和连续消费多个。

import java.util.concurrent.locks.*;
//描述产品
class Clothes
{
    //产品名称
    private String name;
    //产品价格
    private double price;
    //存放产品的容器
    private Clothes[] arr = new Clothes[100];
    //创建一把锁
    private Lock lock = new ReentrantLock();
    //创建和锁绑定的Condition对象，控制生产线程
    private Condition pro = lock.newCondition();
    //创建和锁绑定的Condition对象，控制生产线程
    private Condition con = lock.newCondition();
    //生产使用的下标
    private int propointer;
    //消费使用的下标
    private int conpointer;
    //记录产品数量
    private int count;

    public Clothes(){}
    public Clothes(String name,double price)
    {
        this.name = name;
        this.price = price;
    }

    public String toString()
    {
        return name+",RMB:"+price;
    }

    //生产功能
    public void produce()
    {
        lock.lock();
        try
        {
            //先判断该不该生产，当容器满的时候不能生产
            while(count==arr.length)
            {
                try
                {
                    pro.await();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            arr[propointer] = new Clothes("衬衣",99.99);
            System.out.println(Thread.currentThread().getName()+"...生产了..."+arr[propointer]+"..."+count);
            count++;
            if(++propointer==arr.length)
                propointer = 0;
            con.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
    //消费功能
    public void consume()
    {
        lock.lock();
        try
        {
            //判断该不该消费，当商品数量为0的时候不能消费
            while(count==0)
            {
                try
                {
                    con.await();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            Clothes yifu = arr[conpointer];
            System.out.println(Thread.currentThread().getName()+"---消费了---"+yifu);
            count--;
            if(++conpointer==arr.length)
                conpointer = 0;
            pro.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
}

//生产任务
class Producer implements Runnable
{
    private Clothes clo;
    public Producer(Clothes clo)
    {
        this.clo = clo;
    }
    public void run()
    {
        while(true)
            clo.produce();
    }
}

//消费任务
class Consumer implements Runnable
{
    private Clothes clo;
    public Consumer(Clothes clo)
    {
        this.clo = clo;
    }
    public void run()
    {
        while(true)
            clo.consume();
    }
}


class Demo
{
    public static void main(String[] args) 
    {
        Clothes clo = new Clothes();
        Producer producer = new Producer(clo); 
        Consumer consumer = new Consumer(clo); 
        
        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(producer);

        Thread t3 = new Thread(consumer);
        Thread t4 = new Thread(consumer);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}