1. import java.util.concurrent.locks.*;
   
2. class ProducerConsumerLock
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 Resource r = new Resource();
   
7. 
   
8.                 Thread pro1 = new Thread(new Producer(r));
   
9.                 Thread pro2 = new Thread(new Producer(r));
   
10.                 Thread con1 = new Thread(new Consumer(r));
    
11.                 Thread con2 = new Thread(new Consumer(r));
    
12.                 pro1.start();
    
13.                 pro2.start();
    
14.                 con1.start();
    
15.                 con2.start();
    
16.         }
    
17. }
    
18. 
    
19. class Resource
    
20. {
    
21.         private String name;
    
22.         private int count = 1;
    
23.         private boolean flag = false;
    
24.         Lock lock = new ReentrantLock();
    
25.         Condition con_pro = lock.newCondition();
    
26.         Condition con_con = lock.newCondition();
    
27.         
    
28. 
    
29.         public void set(String name)
    
30.         {
    
31.                 lock.lock();
    
32.                 try
    
33.                 {
    
34.                         while(flag)
    
35.                                 try
    
36.                                 {
    
37.                                         con_pro.await();
    
38.                                 }
    
39.                                 catch (InterruptedException e)
    
40.                                 {
    
41.                                         //此处的异常应该怎么处理，我的意思是说线程真有冻结时应该怎么处理，Thread的interrupt()方法应该用在哪里？
    
42.                                 }
    
43.                                 
    
44.                         this.name = name+"---"+count++;
    
45.                         System.out.println(Thread.currentThread().getName()+".....生产者"+this.name);
    
46.                         flag = true;
    
47.                         con_con.signal();
    
48.                 }
    
49.                 finally
    
50.                 {
    
51.                         lock.unlock();
    
52.                 }
    
53.                
    
54.         }
    
55.         public void out()
    
56.         {
    
57.                 lock.lock();
    
58.                 try
    
59.                 {
    
60.                         while(!flag)
    
61.                                 try
    
62.                                 {
    
63.                                         con_con.await();
    
64.                                 }
    
65.                                 catch (InterruptedException e)
    
66.                                 {
    
67.                                        
    
68.                                 }
    
69.                                 
    
70.                         System.out.println(Thread.currentThread().getName()+"..消费者"+this.name);
    
71.                         flag = false;
    
72.                         con_pro.signal();
    
73.                 }
    
74.                 finally
    
75.                 {
    
76.                         lock.unlock();
    
77.                 }
    
78.         }
    
79. }
    
80. 
    
81. class Producer implements Runnable
    
82. {
    
83.         private Resource res;
    
84.         Producer(Resource res)
    
85.         {
    
86.                 this.res=res;
    
87.         }
    
88.         public void run()
    
89.         {
    
90.                 while(true)
    
91.                 {
    
92.                         res.set("商品");                        
    
93.                 }
    
94.         }
    
95. }
    
96. 
    
97. class Consumer implements Runnable
    
98. {
    
99.         private Resource res;
    
100.         Consumer(Resource res)
     
101.         {
     
102.                 this.res=res;
     
103.         }
     
104.         public void run()
     
105.         {
     
106.                 while(true)
     
107.                 {
     
108.                         res.out();                        
     
109.                 }
     
110.         }
     
111. }

复制代码

interrupt方法在执行后本身就会抛出一个异常，所以不应该把interrupt写在catch里面，这样一定会报错~~~加分哈~~~{:soso_e144:}

public void set(String name)

30.        {

31.                lock.lock();

32.                try

33.                {

34.                        while(flag)

35.                                try

36.                                {

37.                                        con_pro.await();

38.                                }

39.                                catch (InterruptedException e)

40.                                {

41.          e.printStackTrace();                              //此处打印异常信息就可以了，
42.                                }

43.                                

44.                        this.name = name+"---"+count++;

45.                        System.out.println(Thread.currentThread().getName()+".....生产者"+this.name);

46.                        flag = true;

47.                        con_con.signal();

48.                }

49.                finally

50.                {

51.                        lock.unlock();

52.                }

53.               

54.        }
在main()方法中添加interrupt()方：
public static void main(String[] args)

05.        {

06.                Resource r = new Resource();

07.

08.                Thread pro1 = new Thread(new Producer(r));

09.                Thread pro2 = new Thread(new Producer(r));

10.                Thread con1 = new Thread(new Consumer(r));

11.                Thread con2 = new Thread(new Consumer(r));

12.                pro1.start();

13.                pro2.start();

14.                con1.start();
  
15.                con2.start();
                     con1.interrupt();
                     con2.interrup();
                     pro1.interrup();
16.        }

四个线程都可以调用interrupt方法，随意。out()方法里的异常可以像set()方法里一样处理。如果想异常信息更详细，可以在catch里添加一条打印中文的字符串，说明是什么样的异常。

public void set(String name)

30.        {

31.                lock.lock();

32.                try

33.                {

34.                        while(flag)

35.                                try

36.                                {

37.                                        con_pro.await();

38.                                }

39.                                catch (InterruptedException e)

40.                                {

41.          e.printStackTrace();                              //此处打印异常信息就可以了，
42.                                }

43.                                

44.                        this.name = name+"---"+count++;

45.                        System.out.println(Thread.currentThread().getName()+".....生产者"+this.name);

46.                        flag = true;

47.                        con_con.signal();

48.                }

49.                finally

50.                {

51.                        lock.unlock();

52.                }

53.               

54.        }
在main()方法中添加interrupt()方：
public static void main(String[] args)

05.        {

06.                Resource r = new Resource();

07.

08.                Thread pro1 = new Thread(new Producer(r));

09.                Thread pro2 = new Thread(new Producer(r));

10.                Thread con1 = new Thread(new Consumer(r));

11.                Thread con2 = new Thread(new Consumer(r));

12.                pro1.start();

13.                pro2.start();

14.                con1.start();
  
15.                con2.start();
                     con1.interrupt();
                     con2.interrup();
                     pro1.interrup();
16.        }

四个线程都可以调用interrupt方法，随意。out()方法里的异常可以像set()方法里一样处理。如果想异常信息更详细，可以在catch里添加一条打印中文的字符串，说明是什么样的异常。