try...finally搭配的话，一般怎么用，什么情况常用啊？

不管程序有无异常都需要执行 finally
finally的作用用来关闭流、关闭连接、释放或销毁资源。

1. import java.util.concurrent.locks.*;
   
2. 
   
3. class ProducerConsumerDemo2
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 Resource r = new Resource();
   
8. 
   
9.                 Producer pro = new Producer(r);
   
10.                 Consumer con = new Consumer(r);
    
11. 
    
12.                 Thread t1 = new Thread(pro);
    
13.                 Thread t2 = new Thread(pro);
    
14.                 Thread t3 = new Thread(con);
    
15.                 Thread t4 = new Thread(con);
    
16. 
    
17.                 t1.start();
    
18.                 t2.start();
    
19.                 t3.start();
    
20.                 t4.start();
    
21. 
    
22.         }
    
23. }
    
24. 
    
25. /*
    
26. JDK1.5 中提供了多线程升级解决方案。
    
27. 将同步Synchronized替换成现实Lock操作。
    
28. 将Object中的wait，notify notifyAll，替换了Condition对象。
    
29. 该对象可以Lock锁 进行获取。
    
30. 该示例中，实现了本方只唤醒对方操作。
    
31. 
    
32. Lock:替代了Synchronized
    
33.         lock
    
34.         unlock
    
35.         newCondition()
    
36. 
    
37. Condition：替代了Object wait notify notifyAll
    
38.         await();
    
39.         signal();
    
40.         signalAll();
    
41. */
    
42. class Resource
    
43. {
    
44.         private String name;
    
45.         private int count = 1;
    
46.         private boolean flag = false;
    
47.                         //  t1    t2
    
48.         private Lock lock = new ReentrantLock();
    
49. 
    
50.         private Condition condition_pro = lock.newCondition();
    
51.         private Condition condition_con = lock.newCondition();
    
52. 
    
53. 
    
54. 
    
55.         public  void set(String name)throws InterruptedException
    
56.         {
    
57.                 lock.lock();
    
58.                 try
    
59.                 {
    
60.                         while(flag)
    
61.                                 condition_pro.await();//t1,t2
    
62.                         this.name = name+"--"+count++;
    
63. 
    
64.                         System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    
65.                         flag = true;
    
66.                         condition_con.signal();
    
67.                 }
    
68.                 finally
    
69.                 {
    
70.                         lock.unlock();//释放锁的动作一定要执行。
    
71.                 }
    
72.         }
    
73. 
    
74. 
    
75.         //  t3   t4  
    
76.         public  void out()throws InterruptedException
    
77.         {
    
78.                 lock.lock();
    
79.                 try
    
80.                 {
    
81.                         while(!flag)
    
82.                                 condition_con.await();
    
83.                         System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
    
84.                         flag = false;
    
85.                         condition_pro.signal();
    
86.                 }
    
87.                 finally
    
88.                 {
    
89.                         lock.unlock();
    
90.                 }
    
91.                
    
92.         }
    
93. }
    
94. 
    
95. class Producer implements Runnable
    
96. {
    
97.         private Resource res;
    
98. 
    
99.         Producer(Resource res)
    
100.         {
     
101.                 this.res = res;
     
102.         }
     
103.         public void run()
     
104.         {
     
105.                 while(true)
     
106.                 {
     
107.                         try
     
108.                         {
     
109.                                 res.set("+商品+");
     
110.                         }
     
111.                         catch (InterruptedException e)
     
112.                         {
     
113.                         }
     
114.                        
     
115.                 }
     
116.         }
     
117. }
     
118. 
     
119. class Consumer implements Runnable
     
120. {
     
121.         private Resource res;
     
122. 
     
123.         Consumer(Resource res)
     
124.         {
     
125.                 this.res = res;
     
126.         }
     
127.         public void run()
     
128.         {
     
129.                 while(true)
     
130.                 {
     
131.                         try
     
132.                         {
     
133.                                 res.out();
     
134.                         }
     
135.                         catch (InterruptedException e)
     
136.                         {
     
137.                         }
     
138.                 }
     
139.         }
     
140. }
     

复制代码

您好！

finally语句的代码块特点是无论异常是否被捕获都是要被执行的，放在try...catch语句后使用。但特殊情况除外（finally语句之前执行了System.exit(0);）放在try...catch语句后使用。
finally最常见的应用为关闭资源；如在多线程应用里释放锁资源，上面代码是毕老师在讲多线程时的代码，供您参考。