Android中使用CountDownLatch并发多线程操作

Java的concurrent包里面的CountDownLatch其实可以把它看作一个计数器，只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。

        你可以向CountDownLatch对象设置一个初始的数字作为计数值，任何调用这个对象上的await()方法都会阻塞，直到这个计数器的计数值被其他的线程减为0为止。

        CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。

        在Android当中使用CountDownLatch要注意一点，即，需要另外新建一个线程监视工作线程，否则会ANR错误。代码如下：

[java] view plaincopy

1. package com.example.test;  
2.   
3. import java.util.concurrent.CountDownLatch;  
4. import java.util.concurrent.ExecutorService;  
5. import java.util.concurrent.Executors;  
6.   
7.   
8. import android.app.Activity;  
9. import android.os.Bundle;  
10. import android.os.Handler;  
11. import android.os.Message;  
12. import android.util.Log;  
13. /** 
14.  *  
15.  * @Title: MainActivity.java 
16.  * @Package com.example.test 
17.  * @Description: Android当中使用CountDownLatch 
18.  * @author Yang    
19.  * @date 2012-12-25 下午9:30:57 
20.  * @version V1.0 
21.  */  
22. public class MainActivity extends Activity {  
23.   
24.     private DatePickerFragment fragment;  
25.   
26.     @Override  
27.     public void onCreate(Bundle savedInstanceState) {  
28.         super.onCreate(savedInstanceState);  
29.         setContentView(R.layout.activity_main);  
30.         testCountDownLatch();  
31.     }  
32.   
33.     private void testCountDownLatch() {  
34.         LightProgressDialog.create(MainActivity.this, "Test");  
35.         final Handler handler = new Handler() {  
36.             public void handleMessage(Message msg) {  
37.                 if (msg.what == 1){  
38.                     LightProgressDialog.cancelDialog();  
39.                     Log.d("MainActivity","========================SUCESS========================");  
40.                 }  
41.             }  
42.         };  
43.         new Thread() {  
44.             public void run() {  
45.                 CountDownLatch latch = new CountDownLatch(2);// 设置计数值,  
46.                 ExecutorService exec = Executors.newCachedThreadPool();// 创建线程池  
47.                 exec.execute(new TestRunable1(latch));  
48.                 exec.execute(new TestRunable2(latch));  
49.                 try {  
50.                     latch.await();// 等待所有线程完成操作  
51.                 } catch (InterruptedException e) {  
52.                     e.printStackTrace();  
53.                 }  
54.                 handler.sendEmptyMessage(1);  
55.                 exec.shutdown();  
56.             };  
57.         }.start();  
58.   
59.     }  
60.   
61.     class TestRunable1 implements Runnable {  
62.         private CountDownLatch latch;  
63.   
64.         public TestRunable1(CountDownLatch latch) {  
65.             super();  
66.             this.latch = latch;  
67.         }  
68.   
69.         @Override  
70.         public void run() {  
71.                 try {  
72.                     Thread.sleep(1000 * 5);  
73.                 } catch (InterruptedException e) {  
74.                     e.printStackTrace();  
75.                 }  
76.                 latch.countDown();  
77.         }  
78.   
79.     }  
80.   
81.     class TestRunable2 implements Runnable {  
82.         private CountDownLatch latch;  
83.   
84.         public TestRunable2(CountDownLatch latch) {  
85.             super();  
86.             this.latch = latch;  
87.         }  
88.   
89.         @Override  
90.         public void run() {  
91.             try {  
92.                 Thread.sleep(1000 * 3);  
93.                 latch.countDown();  
94.             } catch (InterruptedException e) {  
95.                 e.printStackTrace();  
96.             }  
97.         }  
98.   
99.     }  
100.   
101. }