CountDownLatch实现并发多线程操作

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

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

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

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

1. public class TestActivity extends Activity {  
2.   
3.     @Override  
4.     public void onCreate(Bundle savedInstanceState) {  
5.         super.onCreate(savedInstanceState);  
6.         testCountDownLatch();  
7.     }  
8.   
9.     private void testCountDownLatch() {  
10.         final Handler handler = new Handler() {  
11.             public void handleMessage(Message msg) {  
12.                 if (msg.what == 1){  
13.                  
14.                 }  
15.             }  
16.         };  
17.         new Thread() {  
18.             public void run() {  
19.                 CountDownLatch latch = new CountDownLatch(2);// 设置计数值,  
20.                 ExecutorService exec = Executors.newCachedThreadPool();// 创建线程池  
21.                 exec.execute(new TestRunable1(latch));  
22.                 exec.execute(new TestRunable2(latch));  
23.                 try {  
24.                     latch.await();// 等待所有线程完成操作  
25.                 } catch (InterruptedException e) {  
26.                     e.printStackTrace();  
27.                 }  
28.                 handler.sendEmptyMessage(1);  
29.                 exec.shutdown();  
30.             };  
31.         }.start();  
32.   
33.     }  
34.   
35.     class TestRunable1 implements Runnable {  
36.         private CountDownLatch latch;  
37.   
38.         public TestRunable1(CountDownLatch latch) {  
39.             super();  
40.             this.latch = latch;  
41.         }  
42.   
43.         @Override  
44.         public void run() {  
45.                 try {  
46.                     Thread.sleep(1000 * 5);  
47.                 } catch (InterruptedException e) {  
48.                     e.printStackTrace();  
49.                 }  
50.                 latch.countDown();  
51.         }  
52.   
53.     }  
54.   
55.     class TestRunable2 implements Runnable {  
56.         private CountDownLatch latch;  
57.   
58.         public TestRunable2(CountDownLatch latch) {  
59.             super();  
60.             this.latch = latch;  
61.         }  
62.   
63.         @Override  
64.         public void run() {  
65.             try {  
66.                 Thread.sleep(1000 * 3);  
67.                 latch.countDown();  
68.             } catch (InterruptedException e) {  
69.                 e.printStackTrace();  
70.             }  
71.         }  
72.   
73.     }  
74.   
75. }