生产者与消费者的问题 synchronized wait() 和notify()方法的应用

// 生产者与消费者   synchronized  wait() 和notify()方法的应用
public class ProduceConsume {
    public static void main(String[] args) {
        SyncStack ss = new SyncStack();
        Produce p = new Produce(ss);
        Consume c = new Consume(ss);

        Thread tp = new Thread(p);
        Thread tc = new Thread(c);

        tp.start();
        tc.start();
    }
}

//馒头类
class SteamBread{
    int id;
    SteamBread(int id){
        this.id = id;
    }
    public String toString(){
        return "SteamBread:" + id;
    }
}

//馒头框
class SyncStack{
    int index = 0;
    SteamBread [] stb = new SteamBread[6];

    //将馒头放入到筐中,相当于入栈
    public synchronized void push(SteamBread sb){
        while(index == stb.length){//筐已经满了,需要等待消费者进行消费
            try {
                this.wait();
                System.out.println("--馒头框已经满了...请稍后再生产--");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        this.notify(); //唤醒在此对象上监视的线程,也就是消费者线程
        stb[index] = sb;
        this.index ++;
    }

    //将馒头从框中拿出来,相当于出栈
    public synchronized SteamBread pop(){
        while(index == 0){//筐空了
            try {
                this.wait();
                System.out.println("--馒头框已经空了...请稍后再取--");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        this.notify(); //唤醒在此对象上监视的线程,也就是消费者线程
        this.index --;
        return stb[index];
    }
}

class Consume implements Runnable{
    SyncStack ss = null;
    Consume(SyncStack ss){
        this.ss = ss;
    }


    public void run() {
        for (int i = 0; i < 20; i++) {
            SteamBread sb = ss.pop();
            System.out.println("消费了:" + sb);

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}
class Produce implements Runnable{
    SyncStack ss = null;

    Produce(SyncStack ss){
        this.ss = ss;
    }

    public void run() {
        for (int i = 0; i < 20; i++) {
            SteamBread sb = new SteamBread(i);
            ss.push(sb);
            System.out.println("生产了:" + sb);

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}