CountDownLatch 和CyclicBarrier

来自：http://www.iteye.com/topic/657295多谢作者完美的例子。解决了我的问题！！！

CountDownLatch：

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

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

CyclicBarrier：

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

CyclicBarrier可以多次重复使用

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

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

Java代码

1. packagecom.woxiaoe.study.thread;
3. importjava.util.Random;
4. importjava.util.concurrent.CountDownLatch;
5. importjava.util.concurrent.ExecutorService;
6. importjava.util.concurrent.Executors;
7. importjava.util.concurrent.TimeUnit;
9. /**
10. *模拟项目的开发，只有当每个模块都完成后，项目才完成
11. *每个模块的用时不同
12. *@author小e
13. *
14. *2010-4-30下午07:41:37
15. */
16. classModuleimplementsRunnable{
17. privateCountDownLatchlatch;
18. privateStringmoduleName;
19. privateinttime;//用时
23. publicModule(CountDownLatchlatch,StringmoduleName,inttime){
24. super();
25. this.latch=latch;
26. this.moduleName=moduleName;
27. this.time=time;
28. }
32. @Override
33. publicvoidrun(){
34. try{
35. work();
36. latch.countDown();
37. }catch(InterruptedExceptione){
38. //TODOAuto-generatedcatchblock
39. e.printStackTrace();
40. }
42. }
44. privatevoidwork()throwsInterruptedException{
45. TimeUnit.MILLISECONDS.sleep(time);
46. System.out.println(moduleName+"完成，耗时:"+time);
47. }
48. }
49. classControllerimplementsRunnable{
50. privateCountDownLatchlatch;
52. publicController(CountDownLatchlatch){
53. super();
54. this.latch=latch;
55. }
57. @Override
58. publicvoidrun(){
59. try{
60. latch.await();
61. System.out.println("所有模块都完成，任务完成");
62. }catch(InterruptedExceptione){
63. //TODOAuto-generatedcatchblock
64. e.printStackTrace();
65. }
67. }
69. }
70. publicclassProject{
71. staticfinalintSIZE=20;
72. publicstaticvoidmain(String[]args){
73. CountDownLatchlatch=newCountDownLatch(SIZE);
74. Randomr=newRandom();
75. ExecutorServiceexec=Executors.newCachedThreadPool();
76. Controllercontroller=newController(latch);
77. exec.execute(controller);
78. for(inti=0;i<SIZE;i++){
79. exec.execute(newModule(latch,"模块"+(i+1),r.nextInt(2000)));
80. }
82. exec.shutdown();
84. }
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. packagecom.woxiaoe.study.thread;
3. importjava.util.Random;
4. importjava.util.concurrent.CyclicBarrier;
5. importjava.util.concurrent.ExecutorService;
6. importjava.util.concurrent.Executors;
7. importjava.util.concurrent.TimeUnit;
9. /**
10. *用java模拟4X100接力赛
11. *当结束后报成绩，应用CyclicBarrier
12. *@author小e
13. *
14. *2010-4-30下午08:13:40
15. */
16. classPlayerimplementsRunnable{
17. privateStringname;
18. privateCyclicBarrierbarrier;
19. privatePlayernext;//下一棒
20. privateinttime;//用时
21. privatebooleanrun;//第一棒
22. publicPlayer(Stringname,CyclicBarrierbarrier,booleanrun){
23. super();
24. this.name=name;
25. this.barrier=barrier;
26. this.run=run;
27. }
28. @Override
29. publicvoidrun(){
30. try{
31. synchronized(this){
32. while(!run){//等待队员
33. wait();
34. }
35. }
36. Randomr=newRandom();
37. TimeUnit.MILLISECONDS.sleep(r.nextInt(2000));
38. next(next,11+r.nextInt(2));
39. }catch(InterruptedExceptione){
40. e.printStackTrace();
41. }
43. }
44. privatevoidnext(Playernext,inttime){
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. publicvoidsetTime(inttime){
57. this.time=time;
58. }
59. publicintgetTime(){
60. returnthis.time;
61. }
62. publicvoidsetNext(Playernext){
63. this.next=next;
64. }
65. publicvoidsetRun(booleanrun){
66. this.run=run;
67. }
69. }
70. publicclassRelayRace{
72. publicstaticvoidmain(String[]args)throwsInterruptedException{
73. finalPlayer[]players=newPlayer[4];
74. ExecutorServiceexec=Executors.newCachedThreadPool();
75. CyclicBarrierbarrier=newCyclicBarrier(4,newRunnable(){
77. @Override
78. publicvoidrun(){
79. System.out.println("结束，总用时："+players[3].getTime());
80. }
81. });
82. for(inti=0;i<4;i++){
83. players[i]=newPlayer("队员"+(i+1),barrier,i==0);
84. }
85. for(inti=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(inti=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. }
107. }

Output：

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

来自：