生产者与消费者的问题

Question

//以下是源码
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */package pc;/**
 *
 * @author seven
 */
public class ProducerConsumer {
public static void main(String[] args) {
SyncStack ss = new SyncStack();
Producer p = new Producer(ss);
Consumer c = new Consumer(ss);
new Thread(p).start();
new Thread(c).start();
}
}class WoTou {   //产品类
int id; 
WoTou(int id) {
this.id = id;
}
public String toString() {
return " : " + id;
}
}class SyncStack {  //栈，用来当容器
int index = 0;
WoTou[] arrWT = new WoTou[5];

public synchronized void push(WoTou wt) {  //产品入栈（生产）
while(index == arrWT.length) {
try {
System.out.println("正在等待消费");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
arrWT[index] = wt;
index ++;
}

public synchronized WoTou pop() {  //产品出栈（消费）
while(index == 0) {
try {
                                System.out.println("正在等待生产");
                                this.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<30; i++) {
WoTou wt = new WoTou(i);
ss.push(wt);
System.out.println("生产了" + wt + "号产品");
try {
Thread.sleep(500);
} 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<30; i++) {
WoTou wt = ss.pop();
System.out.println("消费了" + wt + "号产品");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//以下是运行结果生产了 : 0号产品
消费了 : 0号产品
生产了 : 1号产品
生产了 : 2号产品
消费了 : 2号产品
生产了 : 3号产品
生产了 : 4号产品
消费了 : 4号产品
生产了 : 5号产品
生产了 : 6号产品
消费了 : 6号产品
生产了 : 7号产品
生产了 : 8号产品
消费了 : 8号产品
生产了 : 9号产品
正在等待消费
生产了 : 10号产品
消费了 : 9号产品
正在等待消费
生产了 : 11号产品
消费了 : 10号产品
正在等待消费
生产了 : 12号产品
消费了 : 11号产品
正在等待消费
生产了 : 13号产品
消费了 : 12号产品
正在等待消费
生产了 : 14号产品
消费了 : 13号产品
正在等待消费
生产了 : 15号产品
消费了 : 14号产品
正在等待消费
生产了 : 16号产品
消费了 : 15号产品
正在等待消费
生产了 : 17号产品
消费了 : 16号产品
正在等待消费
生产了 : 18号产品
消费了 : 17号产品
正在等待消费
生产了 : 19号产品
消费了 : 18号产品
正在等待消费
生产了 : 20号产品
消费了 : 19号产品
正在等待消费
生产了 : 21号产品
消费了 : 20号产品
正在等待消费
生产了 : 22号产品
消费了 : 21号产品
正在等待消费
生产了 : 23号产品
消费了 : 22号产品
正在等待消费
生产了 : 24号产品
消费了 : 23号产品
正在等待消费
生产了 : 25号产品
消费了 : 24号产品
正在等待消费
生产了 : 26号产品
消费了 : 25号产品
正在等待消费
生产了 : 27号产品
消费了 : 26号产品
正在等待消费
生产了 : 28号产品
消费了 : 27号产品
正在等待消费
生产了 : 29号产品
消费了 : 28号产品
消费了 : 29号产品
消费了 : 7号产品
消费了 : 5号产品
消费了 : 3号产品
消费了 : 1号产品
这是我写的一个生产者与消费者的程序，缓冲区满的时候，等待消费，理应先进行消费，为什么先执行的生产呢？程序的问题出在哪里呢？

Answer 1

应该在pop方法中的this.notify()这里，
这里通知了一个正在等待的线程。push方法上的
生产者被唤醒，然后这时又轮到生产者线程执行
所以生产者先打印，然后又回到消费者，消费者再打印。
不知道理解的对不对，等待更明确的解答......

Answer 2

public class ProducerConsumer{
public ProducerCustomer(){

}
static SyncStack ss = new SyncStack();
static Producer p = new Producer(ss);
static Consumer c = new Consumer(ss);
    public static void main(String[] args) {
        new Thread(p).start();
        new Thread(c).start();
    }
}class WoTou {   //产品类
    int id; 
    WoTou(int id) {
        this.id = id;
    }
    public String toString() {
        return " : " + id;
    }
}class SyncStack {  //栈，用来当容器
    int index = 0;
    WoTou[] arrWT = new WoTou[5];
    ProducerCustomer pc = new ProducerCustomer();
    
    public  void push(WoTou wt) {  //产品入栈（生产）
        while(index == arrWT.length) {
            try {
             synchronized(this){
            
             System.out.println("正在等待消费");
             this.wait();
             }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }synchronized(pc.c) {
        
         pc.c.notify();        
        }
        arrWT[index] = wt;
        index ++;
    }
    
    public  WoTou pop() {  //产品出栈（消费） 
     ProducerCustomer pc = new ProducerCustomer();
        while(index == 0) {
            try {
             synchronized(this){
            
             System.out.println("正在等待生产");
             this.wait();
             }
                
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }synchronized(pc.ss){
        
         pc.ss.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<30; i++) {
            WoTou wt = new WoTou(i);
            ss.push(wt);
System.out.println("生产了" + wt + "号产品");
            try {
                Thread.sleep(500);
            } 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<30; i++) {
            WoTou wt = ss.pop();
System.out.println("消费了" + wt + "号产品");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }            
        }
    }
}
结果：生产了 : 0号产品
消费了 : 0号产品
生产了 : 1号产品
消费了 : 1号产品
生产了 : 2号产品
生产了 : 3号产品
消费了 : 3号产品
生产了 : 4号产品
生产了 : 5号产品
消费了 : 5号产品
生产了 : 6号产品
生产了 : 7号产品
消费了 : 7号产品
生产了 : 8号产品
生产了 : 9号产品
正在等待消费
消费了 : 9号产品
生产了 : 10号产品
正在等待消费
正在等待消费
消费了 : 10号产品
生产了 : 11号产品
消费了 : 11号产品
生产了 : 12号产品
正在等待消费
消费了 : 12号产品
生产了 : 13号产品
正在等待消费
正在等待消费
消费了 : 13号产品
生产了 : 14号产品
消费了 : 14号产品
生产了 : 15号产品
正在等待消费
消费了 : 15号产品
生产了 : 16号产品
正在等待消费
正在等待消费
消费了 : 16号产品
生产了 : 17号产品
消费了 : 17号产品
生产了 : 18号产品
正在等待消费
消费了 : 18号产品
生产了 : 19号产品
正在等待消费
正在等待消费
消费了 : 19号产品
生产了 : 20号产品
消费了 : 20号产品
生产了 : 21号产品
正在等待消费
消费了 : 21号产品
生产了 : 22号产品
正在等待消费
正在等待消费
消费了 : 22号产品
生产了 : 23号产品
消费了 : 23号产品
生产了 : 24号产品
正在等待消费
消费了 : 24号产品
生产了 : 25号产品
正在等待消费
正在等待消费
消费了 : 25号产品
生产了 : 26号产品
消费了 : 26号产品
生产了 : 27号产品
正在等待消费
消费了 : 27号产品
生产了 : 28号产品
正在等待消费
正在等待消费
消费了 : 28号产品
生产了 : 29号产品
消费了 : 29号产品
消费了 : 8号产品
消费了 : 6号产品
消费了 : 4号产品
消费了 : 2号产品