Java线程学习笔记（十）CountDownLatch 和CyclicBarrier

相关文章:  

• 淘宝面试题：如何充分利用多核CPU，计算很大的List中所有整数的和

CountDownLatch ：

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
用给定的计数 初始化 CountDownLatch。由于调用了 countDown()
方法，所以在当前计数到达零之前，await
方法会一直受阻塞。之后，会释放所有等待的线程，await
的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。

 

CountDownLatch 很适合用来将一个任务分为n个独立的部分，等这些部分都完成后继续接下来的任务，CountDownLatch 只能出发一次，计数值不能被重置。

CyclicBarrier：

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

CyclicBarrier可以多次重复使用

 

下面是两个例子，一个为基于CountDownLatch 的模拟项目，一个项目可以分为多个模块，只有但这些模块都完成后才可以继续下一步的工作。

一个为基于CyclicBarrier的接力赛模拟，有四个队员，当跑完后报出最终成绩。

 

 

Java代码  

1. package com.woxiaoe.study.thread;   
2.   
3. import java.util.Random;   
4. import java.util.concurrent.CountDownLatch;   
5. import java.util.concurrent.ExecutorService;   
6. import java.util.concurrent.Executors;   
7. import java.util.concurrent.TimeUnit;   
8.   
9. /**  
10.  * 模拟项目的开发，只有当每个模块都完成后，项目才完成  
11.  * 每个模块的用时不同  
12.  * @author 小e  
13.  *  
14.  * 2010-4-30 下午07:41:37  
15.  */  
16. class Module implements Runnable{   
17.     private CountDownLatch latch;   
18.     private String moduleName;   
19.     private int time;//用时   
20.        
21.        
22.   
23.     public Module(CountDownLatch latch, String moduleName,int time) {   
24.         super();   
25.         this.latch = latch;   
26.         this.moduleName = moduleName;   
27.         this.time = time;   
28.     }   
29.   
30.   
31.   
32.     @Override  
33.     public void run() {   
34.         try {   
35.             work();   
36.             latch.countDown();   
37.         } catch (InterruptedException e) {   
38.             // TODO Auto-generated catch block   
39.             e.printStackTrace();   
40.         }   
41.            
42.     }   
43.        
44.     private void work() throws InterruptedException{   
45.         TimeUnit.MILLISECONDS.sleep(time);   
46.         System.out.println(moduleName + " 完成，耗时:" + time);   
47.     }   
48. }   
49. class Controller implements Runnable{   
50.     private CountDownLatch latch;   
51.   
52.     public Controller(CountDownLatch latch) {   
53.         super();   
54.         this.latch = latch;   
55.     }   
56.   
57.     @Override  
58.     public void run() {   
59.         try {   
60.             latch.await();   
61.             System.out.println("所有模块都完成，任务完成");   
62.         } catch (InterruptedException e) {   
63.             // TODO Auto-generated catch block   
64.             e.printStackTrace();   
65.         }   
66.            
67.     }   
68.        
69. }   
70. public class Project {   
71.     static final int SIZE = 20;   
72.     public static void main(String[] args) {   
73.         CountDownLatch latch = new CountDownLatch(SIZE);   
74.         Random r = new Random();   
75.         ExecutorService exec = Executors.newCachedThreadPool();   
76.         Controller controller = new Controller(latch);   
77.         exec.execute(controller);   
78.         for(int i = 0; i < SIZE; i++){   
79.             exec.execute(new Module(latch, "模块" + (i + 1), r.nextInt(2000)));   
80.         }   
81.            
82.         exec.shutdown();   
83.            
84.     }   
85.   
86. }  

 

 Output：

模块4 完成，耗时:108 模块10 完成，耗时:123 模块7 完成，耗时:136 模块19 完成，耗时:235 模块5 完成，耗时:475 模块11 完成，耗时:653 模块1 完成，耗时:745 模块2 完成，耗时:826 模块20 完成，耗时:1030 模块16 完成，耗时:1151 模块3 完成，耗时:1204 模块15 完成，耗时:1219 模块13 完成，耗时:1274 模块17 完成，耗时:1337 模块8 完成，耗时:1366 模块6 完成，耗时:1491 模块14 完成，耗时:1739 模块18 完成，耗时:1766 模块12 完成，耗时:1883 模块9 完成，耗时:1951 所有模块都完成，任务完成

 

Java代码  

1. package com.woxiaoe.study.thread;   
2.   
3. import java.util.Random;   
4. import java.util.concurrent.CyclicBarrier;   
5. import java.util.concurrent.ExecutorService;   
6. import java.util.concurrent.Executors;   
7. import java.util.concurrent.TimeUnit;   
8.   
9. /**  
10.  * 用java模拟4X100接力赛  
11.  * 当结束后 报成绩，应用CyclicBarrier  
12.  * @author 小e  
13.  *  
14.  * 2010-4-30 下午08:13:40  
15.  */  
16. class Player implements Runnable{   
17.     private String name;   
18.     private CyclicBarrier barrier;   
19.     private Player next;//下一棒   
20.     private int time;//用时   
21.     private boolean run;//第一棒   
22.     public Player(String name, CyclicBarrier barrier, boolean run) {   
23.         super();   
24.         this.name = name;   
25.         this.barrier = barrier;   
26.         this.run = run;   
27.     }   
28.     @Override  
29.     public void run() {   
30.         try {   
31.             synchronized (this) {   
32.                 while(!run){//等待队员   
33.                     wait();   
34.                 }   
35.             }   
36.             Random r = new Random();   
37.             TimeUnit.MILLISECONDS.sleep(r.nextInt(2000));   
38.             next(next,11 + r.nextInt(2));   
39.         } catch (InterruptedException e) {   
40.             e.printStackTrace();   
41.         }   
42.            
43.     }   
44.     private void next(Player next, int time) {   
45.         System.out.println(name + " 用时：" + time + ",交接棒");   
46.         if(next != null){   
47.             next.setTime(this.time + time);   
48.             synchronized (next) {   
49.                 next.setRun(true);   
50.                 next.notify();   
51.             }   
52.         }else{   
53.             System.out.println("跑完，总用时：" + (this.time + time));   
54.         }   
55.     }   
56.     public void setTime(int time) {   
57.         this.time = time;   
58.     }   
59.     public int getTime(){   
60.         return this.time;   
61.     }   
62.     public void setNext(Player next) {   
63.         this.next = next;   
64.     }   
65.     public void setRun(boolean run) {   
66.         this.run = run;   
67.     }   
68.        
69. }   
70. public class RelayRace {   
71.        
72.     public static void main(String[] args) throws InterruptedException {   
73.         final Player[] players = new Player[4];   
74.         ExecutorService exec = Executors.newCachedThreadPool();   
75.         CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {   
76.                
77.             @Override  
78.             public void run() {   
79.                 System.out.println("结束，总用时：" + players[3].getTime());   
80.             }   
81.         });   
82.         for(int i = 0; i < 4; i++){   
83.             players[i] = new Player("队员" + ( i + 1), barrier, i == 0);   
84.         }   
85.         for(int i = 0; i < 4; i++){   
86.             if( i < 3){   
87.                 players[i].setNext(players[i + 1]);   
88.                 exec.execute(players[i]);   
89.             }else{   
90.                 exec.execute(players[3]);   
91.                 break;   
92.             }   
93.         }   
94.         /*TimeUnit.SECONDS.sleep(3);  
95.          * CyclicBarrier 可以重用  
96.         for(int i = 0; i < 4; i++){  
97.             if( i < 3){  
98.                 players[i].setNext(players[i + 1]);  
99.                 exec.execute(players[i]);  
100.             }else{  
101.                 exec.execute(players[3]);  
102.                 break;  
103.             }  
104.         }*/  
105.     }   
106.   
107. }  

 Output：

队员1 用时：11,交接棒队员2 用时：11,交接棒队员3 用时：11,交接棒队员4 用时：12,交接棒跑完，总用时：45