JAVA多线程关于消费者/生产者的设计模式

import javax.swing.plaf.SliderUI;

/*
 * 生产者Producter 
 * 仓库Godown 
 * 消费者    Consumer
 * 生产者和消费者通过仓库而建立起联系，仓库的当前数量低于最大库存量时，生产者线程不断生产产品(修改Godown类的属性的值)
 * 仓库的产品数量大于0时，消费者不断取出产品(修改Godown类的属性的值).当生产者生产的产品等于最大库存值时，
 * 停止生产，当产品数量小于0时，消费者停止消费
 *     
 *         分析：
 *             1涉及到多线程：生产者和消费者，并且可能有多个生产者和多个消费者
 *             2涉及数据共享：仓库的产品数量会被多个生产者和消费者共同操作
 *                         生产者与生产者的同步 生产者与消费者的同步  消费者与消费者的同步(synchronized)
 *             3涉及到线程的通讯：生产者与消费者的通讯(wait和notify)
 */

public class ThreadDemo {
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        Godown godown = new Godown();        //创建一个产品仓库
        Consumer cs = new Consumer(godown);    //创建消费者目标对象并使消费者共享该仓库
        Producter pd = new Producter(godown);//创建生产者目标对象并使其共享该仓库
        Thread tr1 = new Thread(pd);        //创建一个生产者线程
        Thread tr2 = new Thread(pd);        //创建第二个生产者线程
        Thread tr3 = new Thread(cs);        //创建一个消费者线程
        tr1.setName("一号生产者线程");            //修改线程名称
        tr2.setName("二号生产者线程");
        tr3.setName("一号消费者者线程");
        tr1.start();                        //启动线程
        tr2.start();                        
        tr3.start();

    }


}
/*
 * 消费者
 */
class Consumer implements Runnable{
    private Godown godown;
    private Boolean boolea = true;
    public Consumer(Godown godown){
        this.godown = godown;
    }
    @Override
    public void run() {            //不断的取出产品
        while(boolea){
            godown.Consumption();
        }
        
    }
}
    /*
     * 生产者
     */
class Producter implements Runnable{
    
    private Godown godown;
    private Boolean boolea = true;
    public Producter(Godown godown){
        this.godown = godown;
    }
    @Override
    public void run() {        
        while(boolea){        //不断的生产产品
            godown.Production();
        }
        
    }
    
}

class Godown{
    public static final int max_size = 100; //最大库存量 
    public int curnum; //当前库存量默认为0
    public synchronized void Production(){            //生产产品
        if(curnum<max_size){        //如果满足生产条件则开始生产
            curnum++;                
            notify();//生产了产品后通知休眠进程可以工作了(如果唤醒的是别的生产线程，因为共同的对象锁此时处于锁定状态,
                    //所以被唤醒的生产线程会阻塞，如果唤醒的是消费者线程，则消费者线程开始工作)    
            System.out.println(Thread.currentThread().getName()+"生产一个产品   当前剩余产品数量： "+curnum);
            try {
                Thread.currentThread().sleep(250);    //控制生产的速度
                
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            
            try {
                wait();        //不满足生产条件时，生产者线程释放当前的对象锁，进入休眠状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized void Consumption(){
        if(curnum>0){
            
            notify();
            curnum--;
            System.out.println(Thread.currentThread().getName()+"消费一个产品   当前剩余产品数量： "+curnum);
            try {
                Thread.currentThread().sleep(300);
                
            } catch (InterruptedException e) {
            
                e.printStackTrace();
            }
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                
                e.printStackTrace();
            }
            
        }
    }
}