多线程生产者消费者 蒸笼窝头

//多线程生产者消费者 蒸笼窝头
public class  ProducerConsumer{
    public static void main(String[] args)  {
        SyncStack ss = new SyncStack();//实例化一个堆栈蒸笼
        Producer p = new Producer(ss);//实例化生产者，参数用同一个蒸笼ss
        Consumer c = new Consumer(ss);//实例化消费者，参数用同一个蒸笼ss
        new Thread(p).start();//开1个线程 生产者p，调用start()方法
        new Thread(c).start();//开1个线程 消费者c，调用start()方法
    }
}

class Wotou{ //自定义窝头类
    int id;
    Wotou(int id)   {
        this.id = id;
    }
    //重写toString
    public String toString(){
        return "WoTou：" + id;
    }
}

class SyncStack{//自定义的堆栈类，就是蒸笼
    int index = 0;//序数，第几个，初始化为0
    Wotou[] arrWT = new WoTou[6];// 数组 Type[] arrName = new Type[];

    public synchronized void push(WoTou wt) {  //push进入堆栈 进站方法
        while (index == arrWT.length){ //堆栈 蒸笼 满了 用while不用if 就不会catch了异常就跳出if语句
            try {
                this.wait;//访问并锁定此对象的线程wait 
            }catch (InterruptedException e){
                e.printStackTrace();//打印错误站
            }           
        }
        this.notify();//唤醒另一个线程 消费者
        arrWT[index] = wt;//存入元素 到数组里 窝头
        index ++;//序数后++
    }

    public synchronized  WoTou pop(){ //出站方法
        while(index == 0){
        try {
            this.wait;//访问并锁定此对象的线程wait 
            }catch (InterruptedException e){
                e.printStackTrace();//打印错误站
            }   
    }
    this.notify();//唤醒另一个线程 生产者
    index --;//序数先--
    return arrWT[index];//取出元素 窝头
    }
}

class Producer implements Runnable{ //生产者 厨师 线程

    SyncStack ss = null;//生产者必须持有目的地的引用 蒸笼 ,实例化一个堆栈蒸笼
    Producer(SyncStack ss){
        this.ss = ss;
    }

    public void run(){
        for (int i = 0;i<20 ;i++ )  {
            WoTou wt = new WoTou(i);//实例化 序号窝头
            ss.push(wt);//调用堆栈蒸笼进站方法
            System.out.println("生产了:"+wt);
            try {
                Thread.sleep((int)(Math.random()*1000));//执行一次，睡眠1下，让其他线程执行
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable{//消费者 客人 线程
    SyncStack ss = null;//必须持有目的地的引用 蒸笼 ,实例化一个堆栈蒸笼
    Consumer(SyncStack ss){
        this.ss = ss;
    }

    public void run(){
        for (int i = 0;i<20 ;i++ )  {
            WoTou wt = ss.pop();//调用堆栈蒸笼ss出站方法  返回值 是 序号窝头
            System.out.println("消费了:"+wt);
            try {
                Thread.sleep((int)(Math.random()*1000));//执行一次，睡眠1下，让其他线程执行,math 是double要强转int
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}