Java并发编程之——CountDownLatch的使用

电玩女神 2022-05-21 00:23 209阅读 0赞

最近在开发Android项目的时候有一个需求：在Service中开启多个线程并发的执行任务，当这三个线程执行完毕之后，主线程才能继续往下执行。刚开始使用的是AsyncTask+AtomicInteger的方式，然后在onpostexecute回调中对AtomicInteger进行自增且判断其值是否达到了要求的值，如果达到了要求的值就继续执行相应的操作，否则跳过。但是发现这种方式并不能很好的实现想要的效果！于是研究了下Java并发编程中的CountDownLatch使用。

CountDownLatch位于包java.util.concurrent下面，它的应用场景是：有一个任务，需要等待其他几个任务完成之后才能继续执行，这个时候就可以使用CountDownLatch了。

CountDownLatch有一个构造器，count代表计数值，也就是任务的个数。

\[html\]  [view plain][]   [copy][view plain]

1.  public CountDownLatch(int count) \{  
2.         if (count **<** **0**) throw new IllegalArgumentException("count **<** **0**");  
3.         this.sync = new Sync(count);  
4.     \}

还有三个方法：

\[java\]  [view plain][]   [copy][view plain]

1.  **public** **void** await() **throws** InterruptedException \{\} //调用await线程会被挂起，直到count计数值为0才继续执行  
2.  **public** **boolean** await(**long** timeout, TimeUnit unit)**throws** InterruptedException \{\}//和await类似，只不过当等待时间后如果count还没变为0就继续执行。  
3.  **public** **void** countDown() \{    \}//count计数值减一

下面是演示代码：

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.easyliu.java.demo;  
2.    
3.  **import** java.util.concurrent.CountDownLatch;  
4.  **import** java.util.concurrent.ExecutorService;  
5.  **import** java.util.concurrent.Executors;  
6.    
7.  **public** **class** CountDownLatchTest \{  
8.      **private** **static** CountDownLatch sCountDownLatch = **null**;  
9.      **private** **static** **final** **int** THREAD\_NUMBER = 3;  
10.   
11.     /\*\* 
12.      \* @param args 
13.      \*/  
14.     **public** **static** **void** main(String\[\] args) \{  
15.         sCountDownLatch = **new** CountDownLatch(THREAD\_NUMBER);  
16.         //线程池  
17.         ExecutorService fixedThreadPool = Executors  
18.                 .newFixedThreadPool(THREAD\_NUMBER);  
19.         //执行线程  
20.         fixedThreadPool.execute(**new** ConsumeRunnable("one"));  
21.         fixedThreadPool.execute(**new** ConsumeRunnable("two"));  
22.         fixedThreadPool.execute(**new** ConsumeRunnable("three"));  
23.         System.out.println("等待3个子线程执行完毕...");  
24.         **try** \{  
25.             sCountDownLatch.await();  
26.             System.out.println("3个子线程已经执行完毕");  
27.             System.out.println("继续执行主线程");  
28.         \} **catch** (InterruptedException e) \{  
29.             e.printStackTrace();  
30.         \}  
31.     \}  
32.   
33.     **private** **static** **class** ConsumeRunnable **implements** Runnable \{  
34.         **private** String mName;  
35.   
36.         **public** ConsumeRunnable(String name) \{  
37.             **this**.mName = name;  
38.         \}  
39.         **public** **void** run() \{  
40.             System.out.println("子线程" + mName + "正在执行");  
41.             **try** \{  
42.                 Thread.sleep(3000);// 模拟耗时操作  
43.                 System.out.println("子线程" + mName + "执行完毕");  
44.                 sCountDownLatch.countDown();  
45.             \} **catch** (InterruptedException e) \{  
46.                 e.printStackTrace();  
47.             \}  
48.         \}  
49.     \}  
50. \}

输入如下所示：

\[java\]  [view plain][]   [copy][view plain]

1.  等待3个子线程执行完毕...  
2.  子线程two正在执行  
3.  子线程one正在执行  
4.  子线程three正在执行  
5.  子线程one执行完毕  
6.  子线程three执行完毕  
7.  子线程two执行完毕  
8.  3个子线程已经执行完毕  
9.  继续执行主线程  
10.

转载于:https://blog.csdn.net/liuyi1207164339/article/details/51597408

[view plain]: https://blog.csdn.net/liuyi1207164339/article/details/51597408#