1. import java.util.concurrent.locks.*;
   
2. public class ProduceAndConsume
   
3. {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 Drumstick drums=new Drumstick();
    
11.                 Produce2 pro1=new Produce2(drums);
    
12.                 Consume2 con1=new Consume2(drums);
    
13.                 //一个线程控制消费，一个控制生产
    
14.                 Thread t1=new Thread(pro1);
    
15.                 Thread t2=new Thread(con1);
    
16.                 Thread t3=new Thread(pro1);
    
17.                 Thread t4=new Thread(con1);
    
18.                 t1.start();
    
19.                 t2.start();
    
20.                 t3.start();
    
21.                 t4.start();
    
22.                
    
23.         }
    
24. }
    
25. //定义一个生产者类，负责生产
    
26. class Produce2 implements Runnable
    
27. {
    
28.         /*生产者类与消费者类里面同时调用 同一个类的对象，
    
29.          * 以这个类的对象确保操作是同一个资源
    
30.          */
    
31.         private Drumstick d;
    
32.         Produce2 (Drumstick d)
    
33.         {
    
34.                 this.d=d;
    
35.         }
    
36.         public void run()
    
37.         {
    
38.                 while(true)
    
39.                 {
    
40.                         d.pro("鸡腿");
    
41.                         
    
42.                 }
    
43.         }
    
44. }
    
45. //定义一个消费类，负责消费
    
46. class Consume2 implements Runnable
    
47. {
    
48.         private Drumstick d;
    
49.         Consume2 (Drumstick d)
    
50.         {
    
51.                 this.d=d;
    
52.         }
    
53.         public void run()
    
54.         {
    
55.                 while(true)
    
56.                 {
    
57.                         d.con();
    
58.                 }
    
59.         }
    
60. }
    
61. //定义个类为生产与消费的地方
    
62. class Drumstick
    
63. {
    
64.         
    
65.         private String drums; //产品的名字
    
66.         //建立一个布尔型的类，来确保线程调用的情况
    
67.         private boolean flag=false;
    
68.         private int  cons=0;//产品的数量
    
69.         public void Drustick(String drums)
    
70.         {
    
71.                 this.drums=drums;
    
72.         }
    
73.     Lock lock=new ReentrantLock();//不可以使用ReentrantLock() 编译报错
    
74.         public void pro(String drums)
    
75.         {
    
76.                 lock.lock();//编译报错
    
77.                 try
    
78.                 {
    
79.                         while(flag==true)
    
80.                         {  //如果生产了，先休息下，消费下
    
81.                                 try
    
82.                                 {
    
83.                                         this.wait();
    
84.                                 }
    
85.                                 catch (Exception e)
    
86.                                 {
    
87.                                        
    
88.                                 }
    
89.                                 
    
90.                         }
    
91.                         this.drums=drums+cons;
    
92.                         cons++;
    
93.                         System.out.println(Thread.currentThread().getName()+
    
94.                                            "生产---"+this.drums);
    
95.                         flag=true;
    
96.                         this.notifyAll();
    
97.                 }
    
98.                 catch (Exception e) {
    
99.                         // TODO Auto-generated catch block
    
100.                         e.printStackTrace();
     
101.                 }
     
102.                 finally
     
103.                 {
     
104.                         lock.unlock();//编译报错
     
105.                 }
     
106.         
     
107.         }
     
108.         public synchronized void con()
     
109.         {
     
110.                 while(flag==false)
     
111.                 {
     
112.                         //消费完了，没有生产，不能在消费，休息
     
113.                         try
     
114.                         {
     
115.                                 this.wait();
     
116.                         }
     
117.                         catch (Exception e)
     
118.                         {
     
119.                         
     
120.                         }
     
121.                 }
     
122.                 System.out.println(Thread.currentThread().getName()+
     
123.                                    "消费---"+this.drums);
     
124.                 flag=false;
     
125.                 this.notifyAll();
     
126.         
     
127.         }
     
128.         
     
129. }

复制代码

我本来要用lock锁代替synchronized锁进行，优化，但是编译报错，不能使用，哪位帮我看下代码是怎么回事，小弟非常焦急啊

代码没问题啊 ，我试了下都没报错啊 ！

itpower 发表于 2014-2-14 16:48
代码没问题啊 ，我试了下都没报错啊 ！

还是错的，你入学考试如何了？你什么怎么复习的啊  ，我以前好多都忘了，现在都在猛复习的

奋斗的小胖子 发表于 2014-2-14 17:06
还是错的，你入学考试如何了？你什么怎么复习的啊  ，我以前好多都忘了，现在都在猛复习的
...

后天面试，入学考试得了29.1分

itpower 发表于 2014-2-14 17:14
后天面试，入学考试得了29.1分

面试是你点下个环节申请面试，再通知你面试，还是你交完入学的测试，那边看完好就通知你面试啊。还有你什么怎么复习的，教教我啊。我现在复习老烦了，而且感觉效率极低啊。

奋斗的小胖子 发表于 2014-2-14 17:17
面试是你点下个环节申请面试，再通知你面试，还是你交完入学的测试，那边看完好就通知你面试啊。还有你什 ...

我是点了视频面试申请，然后就接到老师的电话通知了，我没复习，我平时都是做题，用那复习哪

itpower 发表于 2014-2-14 17:27
我是点了视频面试申请，然后就接到老师的电话通知了，我没复习，我平时都是做题，用那复习哪 ...

你博客得了多少分啊？前面总共有多少分了？

我自己把lock 改为Reentainlock()  ，就可以了  。lock是不行的 我也搞不懂是为什么。

你的代码中判断标志更改的时候就点问题吧，应该是一生产者在生产结束后应该改成false，而消费者应该改成ture吧
还有你既然用了Lock类，在建立等待唤醒方法怎么不用Conditon对象来实现唤醒呢？貌似this.notifyAll()只能用在同步代码中吧~~我初学，也不知道说得对不对