如下代码，是自己把书上的例子重写了一下，把需要同步的代码段放在了生产者和消费者的类里，没有放在容器（basket）类里，把同一个容器类的对象分别传给生产者和消费者对象，basketp和basketc指向的是同一个容器，但是程序运行的时候报出如下的运行时错误。查过错误信息，知道是同步的代码段出问题了，但是不知道该怎么改？

public class TestProducerConsumer{
        public static void main(String args[]){
                Basket basket = new Basket(6);
                Producer p1 = new Producer(basket);
                Consumer c1 = new Consumer(basket);

                new Thread(p1).start();  //启动生产者
                try {
                        Thread.sleep(3000);
                } catch(InterruptedException e){
                        e.printStackTrace();
                }
                new Thread(c1).start();  //启动消费者
        }       
}

class Mt{  //馒头类
        int mid;
        Mt(int mid){
                this.mid = mid;
        }
}

class Basket {  //篮子  先进后出
        public int index = 0;
        public int capacity;
        public Mt mtarr[];
        public Basket(int capacity) {
                this.capacity=capacity;
                mtarr = new Mt [this.capacity];
        }
}

class Producer implements Runnable {  //生产者
        private static int pid=0;
        public Basket basektp;

        Producer(Basket basket){
                basektp = basket;
        }
       
        public synchronized void run(){
                produce();
        }
       
        public synchronized void produce(){
                while(basektp.index == basektp.capacity)        {
                        try{
                                basektp.wait();
                        }catch (InterruptedException e)        {
                                e.printStackTrace();
                        }
                }
                basektp.mtarr[basektp.index] = new Mt(++pid);
                System.out.println("produced mid:"+basektp.mtarr[basektp.index].mid);
                basektp.index++;
                basektp.notifyAll();
        }
}

class Consumer implements Runnable {  //消费者

        public Basket basektc;
       
        Consumer(Basket basket){
                basektc = basket;
        }
       
        public synchronized void run(){
                consume();
        }

        public synchronized void consume(){
                while (basektc.index==0){
                        try{
                                basektc.wait();
                        }catch (InterruptedException e){
                                e.printStackTrace();
                        }
                }

                System.out.println("consumed mid:"+basektc.mtarr[basektc.index].mid);
                basektc.mtarr[basektc.index]=null;
                basektc.index--;
                basektc.notifyAll();
        }
}

输出的错误信息：
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
        at java.lang.Object.notifyAll(Native Method)
        at Producer.produce(TestProducerConsumer.java:57)
        at Producer.run(TestProducerConsumer.java:43)
        at java.lang.Thread.run(Thread.java:662)
Exception in thread "Thread-1" java.lang.NullPointerException
        at Consumer.consume(TestProducerConsumer.java:82)
        at Consumer.run(TestProducerConsumer.java:70)
        at java.lang.Thread.run(Thread.java:662)

1.java.lang.IllegalMonitorStateException异常原因:
   wait()/notify()/notifyAll(),应该是由监视器对象(锁对象)进行调用,而不能有其他对象调用
2.见代码中标注

1. class Producer implements Runnable {  
   
2.         private static int pid=0;
   
3.         public Basket basektp;
   
4. 
   
5.         Producer(Basket basket){
   
6.                 basektp = basket;
   
7.         }
   
8.         
   
9.         public synchronized void run(){
   
10.                 produce();
    
11.         }
    
12.         
    
13.         public synchronized void produce(){
    
14.                 while(basektp.index == basektp.capacity) {
    
15.                         try{
    
16.                                 this.wait();                                        //1.修改basektp.wait();               
    
17.                         }catch (InterruptedException e) {
    
18.                                 e.printStackTrace();
    
19.                         }
    
20.                 }
    
21.                 basektp.mtarr[basektp.index] = new Mt(++pid);
    
22.                 System.out.println("produced mid:"+basektp.mtarr[basektp.index].mid);
    
23.                 basektp.index++;
    
24.                 this.notifyAll();                                         //1.修改basektp.notifyAll();  
    
25.         }
    
26. }
    
27. 
    
28. class Consumer implements Runnable {  
    
29. 
    
30.         public Basket basektc;
    
31.         
    
32.         Consumer(Basket basket){
    
33.                 basektc = basket;
    
34.         }
    
35.         
    
36.         public synchronized void run(){
    
37.                 consume();
    
38.         }
    
39. 
    
40.         public synchronized void consume(){
    
41.                 while (basektc.index==0){
    
42.                         try{
    
43.                                 this.wait();                                //1.修改basektc.wait();
    
44.                         }catch (InterruptedException e){
    
45.                                 e.printStackTrace();
    
46.                         }
    
47.                 }
    
48. 
    
49.                 System.out.println("consumed mid:"+basektc.mtarr[basektc.index-1].mid);        //2.basektc.index需要-1,因为Producer生产了一个馒头,放在了数组mtarr[0],而basektc.index是1,你在这边准备消费mtarr[1],而mtarr[1]是null,所以造成NullPointerException异常
    
50.                 basektc.mtarr[basektc.index]=null;
    
51.                 basektc.index--;
    
52.                 this.notifyAll();                                                        //1.修改basektc.notifyAll();
    
53.         }
    
54. }

复制代码