求教一个生产者消费者问题

        关于线程的一个生产者消费者问题，但运行时的结果有点异常，还望高手指点…… 不胜感激

运行时结果如下；

消费了：WoTO : 0
生产了：WoTO : 0
生产了：WoTO : 1
消费了：WoTO : 1
……

   应该先生产，再消费，为什么o时会出现上述问题；

代码如下；

package com.thread;

import java.util.Random;
  /**
   * 这是一个生产者消费者的例子；
   * 首先用栈模仿一个篮子；
   * 然后创建一个馒头生产者的线程；
   * 再创建一个消费者的线程；
   *
   *
   * wait 方法和  sleep方法的区别；
   * wait 是object 的放法；
   * 而 sleep 是 Thread的方法；
   * wait时别的线程可以访问锁定对象；
   * sleep时别的线程不可以访问锁定对象；
   * */
public class TextPorducerConsumer {
 public static void main(String[] args) {
      SyncStack ss = new SyncStack();
      Producer p = new Producer(ss);
      Customer c = new Customer(ss);
      new Thread(p).start();
      new Thread(c).start();
 }
}

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

class SyncStack {//用栈模仿篮子
 int index = 0;
 WoTo[] arrWT = new WoTo[6];
 
 public synchronized void push(WoTo wt) {//为了避免加的时候出错；
  while (index == arrWT.length) {
   try {
    this.wait();//wait的时候，
   } catch (InterruptedException e) {
    e.printStackTrace();
   }//object里的方法
  }
  this.notify();//叫醒一个
  arrWT[index] = wt;
  index++;
 }
 
 public synchronized WoTo pop() {
  while (index == 0) {
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  this.notify();
  index--;
  return arrWT[index];
 }
}

class Producer implements Runnable {//生产者
 SyncStack  ss = null;
     public Producer( SyncStack ss) {
        this.ss = ss;
     }
 public void run() {
  for (int i=0;i<10;i++) {
   WoTo wt = new WoTo(i);
   ss.push(wt);
   System.out.println("生产了：" + wt);
   try {
    Thread.sleep((int)Math.random()*200);//让线程睡眠一会，好让另一个线程有机会执行；
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}

class Customer implements Runnable {//消费者
 SyncStack  ss = null;
 public Customer( SyncStack ss) {
  this.ss = ss;
 }
 public void run() {
  for (int i=0;i<10;i++) {
   WoTo tt = ss.pop();
   System.out.println("消费了：" + tt);
   try {
   Thread.sleep((int)Math.random()*1000);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  }
 }
}