在JDK1.5之前，解决生产者和消费者问题，
用的是synchronized同步+while+notify()；
但是这种方法很不安全，很容易让线程全部陷入无限等待状态。
于是我们改用notiyfyAll();来解决。

这样虽然解决了安全问题，但还是存在不足和安全隐患。
notifyAll方法唤醒了线程池中全部的线程，
这并不是我们想要的！
而且，同步套同步很容易发生死锁！

在JDK1.5中提供了显示的锁机制，完美的解决了上述问题。
它既可以做到只唤醒对方线程，而不唤醒己方线程，
又能够让一个锁绑定多个对象！

下面我们首先来看看JDK1.5新特性吧！
还是用2个生产者线程和2个消费者线程来展示。

1. import java.util.concurrent.locks.*;
   
2. //一、定义资源类
   
3. class Resource
   
4. {
   
5.         private String name;//商品名称
   
6.         private int count = 1;//商品编号
   
7.         private boolean flag = false;//资源监视器
   
8.         private Lock lock = new ReentrantLock();//建立一个锁对象，注意这里只有一把锁。注意，Lock是接口，不可以直接创建对象
   
9.         private Condition condition_Pro = lock.newCondition();//建立与lock实例一起使用的Condition实例，生产者使用
   
10.         private Condition condition_Con = lock.newCondition();//建立与lock实例一起使用的Condition实例，消费者使用
    
11. 
    
12.         //设置商品名称，商品编号自增，并打印设置结果
    
13.         public void set(String name)throws InterruptedException
    
14.         {
    
15.                 lock.lock();//生产者线程获取锁。替换原来的synchronized
    
16.                 try
    
17.                 {
    
18.                         while(flag)//当资源监视器为true时，生产者线程等待
    
19.                                 condition_Pro.await();//生产者线程等待，并throws InterruptedException
    
20.                         this.name = name;//获取商品名称
    
21.                         System.out.println(Thread.currentThread().getName()+"是生产者线程，生产的商品名称为："+name+"商品编号为："+count);
    
22.                         count++;//商品编号自增
    
23.                         flag = true;//把资源监视器改为true
    
24.                         condition_Con.signal();//只唤醒消费者线程
    
25.                 }
    
26.                 finally
    
27.                 {       
    
28.                         lock.unlock();//一定要释放锁
    
29.                 }
    
30.                        
    
31.         }
    
32. 
    
33.         //取出商品，并展示所取出的商品编号
    
34.         public void get()throws InterruptedException
    
35.         {
    
36.                 lock.lock();//消费者线程获取锁
    
37.                 try
    
38.                 {
    
39.                         while(!flag)//如果资源监视器为false，消费者线程等待,并抛出InterruptedException
    
40.                                 condition_Con.await();
    
41.                         System.out.println(Thread.currentThread().getName()+"是消费者线程，消费的商品名称为："+name+"商品编号为：......."+count);
    
42.                         flag = false;//把资源监视器改为false
    
43.                         condition_Pro.signal();//只唤醒生产者线程
    
44.                 }
    
45.                 finally
    
46.                 {
    
47.                         lock.unlock();//一定要释放锁
    
48.                 }       
    
49.         }
    
50. }
    
51. 
    
52. //二、定义生产者类
    
53. class Producer implements Runnable
    
54. {
    
55.         private Resource r;//引用Resource类型变量r
    
56. 
    
57.         //重载构造函数，避免建立多个对象
    
58.         Producer(Resource r)
    
59.         {
    
60.                 this.r = r;
    
61.         }
    
62. 
    
63.         //覆盖run方法
    
64.         public void run()
    
65.         {
    
66.                 try
    
67.                 {
    
68.                         while(true)//让生产者一直在生产
    
69.                         r.set("商品");
    
70.                 }
    
71.                 catch (InterruptedException e)
    
72.                 {
    
73.                         //暂不处理，以利于观察结果
    
74.                 }
    
75.                
    
76.                
    
77.         }
    
78. 
    
79. }
    
80. 
    
81. //三、定义消费者类
    
82. class Consumer implements Runnable
    
83. {
    
84.         private Resource r;//引用Resource类型变量r
    
85. 
    
86.         //重载构造函数，和生产者线程使用同一资源对象
    
87.         Consumer(Resource r)
    
88.         {
    
89.                 this.r =r;
    
90.         }
    
91. 
    
92.         //覆盖run方法
    
93.         public void run()
    
94.         {
    
95.                 try
    
96.                 {
    
97.                                         while(true)//让消费者一直取商品
    
98.                         r.get();
    
99.                 }
    
100.                 catch (InterruptedException e)
     
101.                 {
     
102.                         //暂不处理，方便观察
     
103.                 }
     
104.         }
     
105. }
     
106. 
     
107. //四、定义测试类
     
108. class MyProducerConsumerDemo2
     
109. {
     
110.         public static void main(String[] args)
     
111.         {
     
112.                 Resource r = new Resource();//建立资源
     
113.                 Producer p = new Producer(r);//建立生产者
     
114.                 Consumer c= new Consumer(r);//建立消费者
     
115.                 Thread tp1 = new Thread(p);//建立生产者线程1
     
116.                 Thread tp2 = new Thread(p);//建立生产者线程2
     
117.                 Thread tp3 = new Thread(p);//建立生产者线程3
     
118.                 Thread tc1 = new Thread(c);//建立消费者线程1
     
119.                 Thread tc2 = new Thread(c);//建立消费者线程2
     
120.                 Thread tc3 = new Thread(c);//建立消费者线程3
     
121.                 tp1.start();//启动生产者线程1
     
122.                 tp2.start();//启动生产者线程2
     
123.                 tp3.start();//启动生产者线程3
     
124.                 tc1.start();//启动消费者线程1
     
125.                 tc2.start();//启动消费者线程2
     
126.                 tc3.start();//启动生产者线程3
     
127.         }
     
128. }
     

复制代码

发帖都是0回复啊，囧！