1. import java.util.concurrent.locks.*;
   
2. class Resource
   
3. {
   
4. //        定义商品名称和编号
   
5.         private String name;
   
6.         private int count=1;
   
7. //        添加一个标记，如果为假则生产否则不生产只消费。
   
8.         boolean  flag=false;
   
9. //        为方便起见，将生产馒头方式和消费馒头方式定义在这里
   
10.         Lock lock=new ReentrantLock();
    
11. //        根据锁获取监视器方法对象
    
12.         Condition c=lock.newCondition();
    
13.         public  void set(String name)
    
14.         {
    
15. //        对于生产者，如果为真的话代表有馒头需要等待，否则就生产。生产完之后要将标记改为价，唤醒消费者，自己再等待
    
16.                 try{
    
17.                         lock.lock();
    
18.                         while(flag)
    
19.                         {
    
20.                                 try{c.await();}catch(InterruptedException e){}
    
21.                         }
    
22.                                                 this.name=name+"--"+count;
    
23.                                                 System.out.println(Thread.currentThread().getName()+"...生产者..."+name+count);
    
24.                                                 count++;
    
25.                                                 flag=true;
    
26.                                                 c.signalAll();
    
27.                         }finally{
    
28.                                 lock.unlock();
    
29.                 }
    
30.                
    
31.         }
    
32.         public synchronized void get()
    
33.         {
    
34. //                对于消费者如果为假的话表示没有馒头需要等待，如果为真的话就消费，然后在将标记改为假，唤醒生产者，自己再等待。
    
35.                 try{
    
36.                                 lock.lock();
    
37.                         while(!flag)
    
38.                         {
    
39.                                         try{c.await();}catch(InterruptedException e){}
    
40.                         
    
41.                                                 System.out.println(Thread.currentThread().getName()+"...消费者..."+name);
    
42.                                                 flag=false;
    
43.                                                 c.signalAll();
    
44.                                        
    
45.                         }
    
46.                 }
    
47.                 finally{
    
48.                         lock.unlock();
    
49.                 }
    
50.                
    
51. }
    
52. class Producer implements Runnable
    
53. {
    
54. //        此处需要使用馒头对象调用生产馒头方法，如果new对象的话，消费者类中也是new对象，那么生产和消费的就不是同一个对象了
    
55. //        ，简单说编号就错了。为了保证资源唯一，可以将馒头对象传递给生产者，消费者，这就唯一了。所以定义在构造函数中，一初始化就有资源对应。
    
56.         Resource r;
    
57.         Producer(Resource r)
    
58.         {
    
59.                 this.r=r;
    
60.         }
    
61.         public void run()
    
62.         {
    
63.                 while(true)
    
64.                 {
    
65.                         r.set("馒头");
    
66.                 }
    
67.         }
    
68. }
    
69. 
    
70. class Consumer implements Runnable
    
71. {
    
72.         Resource r;
    
73.         Consumer(Resource r)
    
74.         {
    
75.                 this.r=r;
    
76.         }
    
77.         public void run()
    
78.         {
    
79.                 while(true)
    
80.                 {
    
81.                         r.get();
    
82.                 }
    
83.         }
    
84. }
    
85. class ProductorConsumerDemo
    
86. {
    
87. 
    
88.         public static void main(String[] args)
    
89.         {
    
90.                 Resource r=new Resource();
    
91.                 Producer p=new Producer(r);//创建生产任务
    
92.                 Consumer c=new Consumer(r);//创建消费任务
    
93.                 Thread t0=new Thread(p);//创建线程明确生产任务
    
94.                 Thread t1=new Thread(p);//创建线程明确生产任务
    
95.                 Thread t2=new Thread(c);//创建线程明确消费任务
    
96.                 Thread t3=new Thread(c);//创建线程明确生产任务
    
97.                 t0.start();
    
98.                 t1.start();
    
99.                 t2.start();
    
100.                 t3.start();
     
101.         }
     
102. 
     
103. }

复制代码

我怎么看你消费代码最后唤醒消费者监视器下线程。p.singleall

陈文杰 发表于 2014-1-31 21:54
哥们，把消费者唤醒生产者c改为p，你手误。

图已经粘贴完了。我现在写的还不是最终版的生产者消费者例子，现在只有一个锁，所有线程即生产者消费者线程都绑定在这个锁上，唤醒时是唤醒所有的线程，虽然效率有点低，但逻辑应该是没有问题的。就是eclipse在main()函数上老是报错，求高手再看一下是什么问题。

一定图方便粘贴没改完

哥们，把消费者唤醒生产者c改为p，你手误。

问题是主函数老是报错，不知道到是为什么？求高手指点。