多消费者 多生产者
同时生产和消费，最大库存量20.

将生产和消费放到两个实现了Runnable类中，使多个他们能够同时运行
在Resource类中，单例模式创建仓库资源实例，
实现了生产和消费两个方法，使用synchronized同步方法
full和empty控制库存量决定是否能够生产和消费，使用while循环wait判断条件，notify通知所有等待线程能够使用共享数据。

没有用到1.5封装的同步对象，只为了熟悉生产者消费者的经典模型，多多指教

1. public class PCRDemo{
   
2.         public static void main(String [] args){
   
3.                 Producer p = new Producer();
   
4.                 Customer c = new Customer();
   
5.                
   
6.                 Thread t1 = new Thread(p);
   
7.                 Thread t2 = new Thread(p);
   
8.                 Thread t3 = new Thread(p);
   
9.                
   
10.                 Thread t4 = new Thread(c);
    
11.                 Thread t5 = new Thread(c);
    
12.                 Thread t6 = new Thread(c);
    
13.                
    
14.                 t1.start();
    
15.                 t2.start();
    
16.                 t3.start();
    
17.                 t4.start();
    
18.                 t5.start();
    
19.                 t6.start();
    
20.         }
    
21. }
    
22. 
    
23. class Resource{
    
24.         private static Resource resource = null;
    
25.         public boolean empty = true ;
    
26.         public boolean full = false ;
    
27.         private String resName = "res";
    
28.         public int count = 0;
    
29.         private Resource(){}
    
30.        
    
31.         public static Resource getInstance(){
    
32.                 if(resource == null){
    
33.                         synchronized(Resource.class){
    
34.                                 if(resource == null)
    
35.                                         resource = new Resource();
    
36.                         }
    
37.                 }
    
38.                 return resource;
    
39.         }
    
40.        
    
41.         public synchronized void produce(){
    
42.                 while (full){
    
43.                         try{
    
44.                                 this.wait();
    
45.                         }
    
46.                         catch(Exception e){
    
47.                                 throw new RuntimeException("It is full!");
    
48.                         }
    
49.                 }
    
50.                 count ++;
    
51.                 String name = resName+"-"+ count;
    
52.                 System.out.println(Thread.currentThread().getName()+": Produce "+name+"   It has "+count+"Resources ");
    
53.                 empty = false;
    
54.                 if(count>=20){
    
55.                         full = true;
    
56.                 }
    
57.                 notifyAll();
    
58.                 try{
    
59.                         Thread.sleep(60);
    
60.                 }
    
61.                 catch(Exception e){
    
62.                 }
    
63.         }
    
64.        
    
65.         public synchronized void consume(){
    
66.                 while (empty){
    
67.                         try{
    
68.                                 this.wait();
    
69.                         }
    
70.                         catch(Exception e){
    
71.                         }
    
72.                 }
    
73.                 String name = resName+"-"+ count;
    
74.                 count --;
    
75.                 System.out.println(Thread.currentThread().getName()+": Consume "+name+"   It has "+count+"Resources ");
    
76.                 full = false;
    
77.                 if(count <= 0){
    
78.                         empty=true;               
    
79.                 }
    
80.                 notifyAll();
    
81.                 try{
    
82.                         Thread.sleep(10);
    
83.                 }
    
84.                 catch(Exception e){
    
85.                 }
    
86.         }
    
87. }
    
88. 
    
89. class Producer implements Runnable{
    
90.         private Resource resource = Resource.getInstance();
    
91.         public void run(){
    
92.                 while (true)
    
93.                         resource.produce();
    
94.         }
    
95. }
    
96. 
    
97. class Customer implements Runnable{
    
98.         private Resource resource = Resource.getInstance();
    
99.         public void run(){
    
100.                 while (true)
     
101.                         resource.consume();
     
102.         }
     
103. }

复制代码

哇，你写的真好，不过还是有几点感觉有点问题，（1）单例模式的话，你应该私有化Resource类的构造方法，但是你没有。（2）感觉你那个empty和full没什么用，完全可以使用count进行判断。其他觉得写得都非常好，例如单例模式的双if，而且使用了类级别的锁，还有生产和消费方法中用while进行循环判断，很不错。

兮兮之c 发表于 2015-1-24 23:46
哇，你写的真好，不过还是有几点感觉有点问题，（1）单例模式的话，你应该私有化Resource类的构造方法，但 ...

29 行 是单例的构造方法私有化

使用empty和full是自己在写代码时候，下意识使用锁的思想，大概用count会没那种感觉

谢谢指导~