1. /*
   
2. 生产者生产商品，供消费者使用
   
3. 有两个或者多个生产者，生产一次就等待消费一次
   
4. 有两个或者多个消费者，等待生产者生产一次就消费掉
   
5. */  
   
6.   
   
7. import java.util.concurrent.locks.*;  
   
8.   
   
9. class Resource   
   
10. {     
    
11.     private String name;  
    
12.     private int count=1;  
    
13.     private boolean flag = false;  
    
14.       
    
15.     //多态  
    
16.     private Lock lock=new ReentrantLock();  
    
17.   
    
18.     //创建两Condition对象，分别来控制等待或唤醒本方和对方线程  
    
19.     Condition condition_pro=lock.newCondition();  
    
20.     Condition condition_con=lock.newCondition();  
    
21.   
    
22.     //p1、p2共享此方法  
    
23.     public void setProducer(String name)throws InterruptedException  
    
24.     {  
    
25.         lock.lock();//锁  
    
26.         try  
    
27.         {  
    
28.             while(flag)//重复判断标识，确认是否生产  
    
29.                 condition_pro.await();//本方等待  
    
30.   
    
31.             this.name=name+"......"+count++;//生产  
    
32.             System.out.println(Thread.currentThread().getName()+"...生产..."+this.name);//打印生产  
    
33.             flag=true;//控制生产\消费标识  
    
34.             condition_con.signal();//唤醒对方  
    
35.         }  
    
36.         finally  
    
37.         {  
    
38.             lock.unlock();//解锁，这个动作一定执行  
    
39.         }  
    
40.          
    
41.     }  
    
42.   
    
43.     //c1、c2共享此方法  
    
44.     public void getConsumer()throws InterruptedException  
    
45.     {  
    
46.         lock.lock();  
    
47.         try  
    
48.         {  
    
49.             while(!flag)//重复判断标识，确认是否可以消费  
    
50.                 condition_con.await();  
    
51.   
    
52.             System.out.println(Thread.currentThread().getName()+".消费."+this.name);//打印消费  
    
53.             flag=false;//控制生产\消费标识  
    
54.             condition_pro.signal();  
    
55.         }  
    
56.         finally  
    
57.         {  
    
58.             lock.unlock();  
    
59.         }  
    
60.   
    
61.     }  
    
62. }  
    
63.   
    
64. //生产者线程  
    
65. class Producer implements Runnable   
    
66. {  
    
67.     private Resource res;  
    
68.     Producer(Resource res)  
    
69.     {  
    
70.         this.res=res;  
    
71.     }  
    
72.     //复写run方法  
    
73.     public void run()  
    
74.     {  
    
75.         while(true)  
    
76.         {  
    
77.             try  
    
78.             {  
    
79.                 res.setProducer("商品");  
    
80.             }  
    
81.             catch (InterruptedException e)  
    
82.             {  
    
83.             }  
    
84.         }  
    
85.     }  
    
86. }   
    
87. //消费者线程  
    
88. class Consumer implements Runnable  
    
89. {  
    
90.     private Resource res;  
    
91.     Consumer(Resource res)  
    
92.     {  
    
93.         this.res=res;  
    
94.     }  
    
95.     //复写run  
    
96.     public void run()  
    
97.     {  
    
98.         while(true)  
    
99.         {  
    
100.             try  
     
101.             {  
     
102.                 res.getConsumer();  
     
103.             }  
     
104.             catch (InterruptedException e)  
     
105.             {  
     
106.             }  
     
107.         }  
     
108.     }  
     
109.   
     
110. }  
     
111.   
     
112. class  ProducerConsumer  
     
113. {  
     
114.     public static void main(String[] args)   
     
115.     {  
     
116.         Resource res=new Resource();  
     
117.   
     
118.         new Thread(new Producer(res)).start();//第一个生产线程 p1  
     
119.         new Thread(new Consumer(res)).start();//第一个消费线程 c1  
     
120.   
     
121.         new Thread(new Producer(res)).start();//第二个生产线程 p2  
     
122.         new Thread(new Consumer(res)).start();//第二个消费线程 c2  
     
123.     }  
     
124. }  
     

复制代码

你学了多久了