1. import java.util.concurrent.locks.*;
   
2. class Resourse
   
3. {
   
4.         String name;
   
5.         int num=1;
   
6.         boolean flag=false;
   
7. Lock lock=new ReentrantLock();
   
8.         Condition consumer_con=lock.newCondition();
   
9.         Condition producer_con=lock.newCondition();
   
10.         public  void set(String name)
    
11.         {
    
12.                 lock.lock();
    
13.                 try
    
14.                 {
    
15.                         while(flag)
    
16.                         try
    
17.                         {
    
18.                                 consumer_con.await();
    
19.                         }
    
20.                         catch (InterruptedException e)
    
21.                         {
    
22.                         }
    
23.                         this.name=name+num;
    
24.                         num++;
    
25.                         System.out.println(Thread.currentThread().getName()+"。。produce。。"+this.name);
    
26.                         flag=true;
    
27.                         producer_con.signal();
    
28.                 }finally
    
29.                 {
    
30.                         lock.unlock();
    
31.                 }
    
32.         }
    
33.         public void out()
    
34.         {
    
35.                 try
    
36.                 {
    
37.                         while(!flag)
    
38.                         try
    
39.                         {
    
40.                                 producer_con.await();
    
41.                         }
    
42.                         catch (InterruptedException e)
    
43.                         {
    
44.                         }
    
45.                         System.out.println(Thread.currentThread().getName()+"..con.."+this.name);
    
46.                         flag=false;
    
47.                         consumer_con.signal();
    
48.                 }finally
    
49.                 {
    
50.                         lock.unlock();
    
51.                 }
    
52.         }
    
53. }
    
54. class Producer implements Runnable
    
55. {
    
56.         Resourse r;
    
57.         Producer(Resourse r)
    
58.         {
    
59.                 this.r=r;
    
60.         }
    
61.         public void run()
    
62.         {
    
63.                 while(true)
    
64.                 {
    
65.                     r.set("北京全聚德烤鸭！！！");
    
66.                 }
    
67.         }
    
68. }
    
69. class Consumer implements Runnable
    
70. {
    
71.         Resourse r;
    
72.         Consumer(Resourse r)
    
73.         {
    
74.                 this.r=r;
    
75.         }
    
76.         public void run()
    
77.         {        
    
78.                 while(true)
    
79.                 {
    
80.            r.out();
    
81.                 }
    
82.         }
    
83. }
    
84. class ProConDemo1
    
85. {
    
86.         public static  void main(String[] args)
    
87.         {
    
88.                 Resourse r=new Resourse();
    
89.                 Consumer con=new Consumer(r);
    
90.                 Producer pro=new Producer(r);
    
91.                 Thread t1=new Thread(con);
    
92.                 Thread t2=new Thread(pro);
    
93.                 t1.start();
    
94.                 t2.start();
    
95.         }
    
96. }

复制代码

问题是编译没出错，到解释的时候抛出：Lang.illegalMonitorStateException

谢谢呀，看到你们才知道自己的水平。

反正以后写代码要认真一点，也要尝试着去写注释语句，不然以后看的时候，不知道这一大片是啥意思

    lock.lock();//运行错误的原因是这里忘记加锁了

运行的时候提示的有第几行错误，你可以根据提示去检查，去修改，加油

1.   public  void set(String name)
   
2.         {
   
3.                 lock.lock();
   
4.                 try
   
5.                 {
   
6.                         while(flag)
   
7.                         try
   
8.                         {
   
9.                         //这应该是让生产者等待，根据你定义的名称是让消费者等待，名称易混淆，定义的时候要要加上注释，便于阅读，下边代码雷同
   
10.                                 consumer_con.await();
    
11.                         }
    
12.                         catch (InterruptedException e)
    
13.                         {
    
14.                         }
    
15.                         this.name=name+num;
    
16.                         num++;
    
17.                         System.out.println(Thread.currentThread().getName()+"。。produce。。"+this.name);
    
18.                         flag=true;
    
19.                         producer_con.signal();
    
20.                 }finally
    
21.                 {
    
22.                         lock.unlock();
    
23.                 }
    
24.         }
    
25.         public void out()
    
26.         {
    
27.                        [color=Red] lock.lock();[/color]//运行错误的原因是这里忘记加锁了
    
28.                 try
    
29.                 {
    
30.                         while(!flag)
    
31.                         try
    
32.                         {
    
33.                                 producer_con.await();
    
34.                         }
    
35.                         catch (InterruptedException e)
    
36.                         {
    
37.                         }
    
38.                         System.out.println(Thread.currentThread().getName()+"..con.."+this.name);
    
39.                         flag=false;
    
40.                         consumer_con.signal();
    
41.                 }finally
    
42.                 {
    
43.                         lock.unlock();
    
44.                 }
    
45.         }

复制代码

IllegalMonitorStateException表示出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
你程序里面表示生产者的线程唤醒了生产者，消费者唤醒了消费者