在java中CycliBarriar和CountDonwLatch有什么区别

文章转自:http://blog.csdn.net/wangxuelei036/article/details/78038472

CyclicBarrier和CountdownLatch是java 1.5中提供的一些非常有用的辅助类来帮助我们进行并发编程。

这两个的区别是CyclicBarrier可以重复使用已经通过的障碍，而CountdownLatch不能重复使用。

CountdownLatch: 

一个线程(或者多个)，等待另外N个线程完成某个事情之后才能执行。是并发包中提供的一个可用于控制多个线程同时开始某个动作的类，其采用的方法为减少计数的方式，当计数减至零时位于latch.Await()后的代码才会被执行，CountDownLatch是减计数方式，计数==0时释放所有等待的线程；CountDownLatch当计数到0时，计数无法被重置；

CyclicBarrier:

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。 即:N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。CyclicBarrier是当await的数量到达了设置的数量的时候，才会继续往下面执行，CyclicBarrier计数达到指定值时，计数置为0重新开始。

对于CountDownLatch来说，重点是那个“一个线程”,是它在等待，而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。

CountdownLatch测试类：

[html]  view plain  copy

1. import java.util.concurrent.CountDownLatch;  
2. import java.util.concurrent.Executor;  
3. import java.util.concurrent.Executors;  
4.   
5. /**  
6.  * 测试多个线程结束后开始线程  
7.  */  
8. public class TestCountDownLatch {  
9.     public static void main(String[] args) throws Exception {  
10.         CountDownLatch countDownLatch = new CountDownLatch(5);  
11.         Executor executor = Executors.newFixedThreadPool(5);  
12.         //测试阻塞其他线程  
13.          new Thread(new MyRunnable(countDownLatch)).start();  
14.          //为了测试效果进行线程休眠  
15.         Thread.sleep(1000);  
16.          for(int i = 1;i<=5;i++){  
17.                 countDownLatch.countDown();  
18.                 System.out.println("第"+i+"调用countDown方法结束");  
19.                 //为了测试效果进行线程休眠  
20.                 Thread.sleep(1000);  
21.          }  
22.           
23.         /*  
24.          * 测试阻塞主线程  
25.           
26.         for (int i = 1; i <= 5; i++) {  
27.             new Thread(new MyRunnable1(countDownLatch,i+"")).start();  
28.             Thread.sleep(1000);  
29.         }  
30.         try {  
31.             System.out.println("主线程阻塞");  
32.             countDownLatch.await();  
33.             System.out.println("主线程继续执行");  
34.         } catch (InterruptedException e) {  
35.             e.printStackTrace();  
36.         } */  
37.   
38.     }  
39.   
40. }  
41.   
42. class MyRunnable implements Runnable {  
43.     CountDownLatch countDownLatch;  
44.   
45.     public MyRunnable(CountDownLatch countDownLatch) {  
46.         this.countDownLatch = countDownLatch;  
47.     }  
48.   
49.     @Override  
50.     public void run() {  
51.         try {  
52.             System.out.println("进入线程，即将进入阻塞状态");  
53.             //调用await进行线程阻塞  
54.             countDownLatch.await();  
55.             System.out.println("线程进行执行...");  
56.         } catch (InterruptedException e) {  
57.             e.printStackTrace();  
58.         }  
59.     }  
60. }  
61.   
62. class MyRunnable1 implements Runnable {  
63.     private CountDownLatch countDownLatch;  
64.     private String mark;  
65.   
66.     public MyRunnable1(CountDownLatch countDownLatch, String mark) {  
67.         super();  
68.         this.countDownLatch = countDownLatch;  
69.         this.mark = mark;  
70.     }  
71.   
72.     @Override  
73.     public void run() {  
74.         System.out.println(mark+"号线程开始");  
75.         try {  
76.             //使线程休眠，看到更好的测试效果  
77.             Thread.sleep(5000);  
78.         } catch (InterruptedException e) {  
79.             e.printStackTrace();  
80.         }  
81.         System.out.println(mark+"号线程结束");  
82.         //调用CountDownLatch的countDown方法进行次数减1  
83.         countDownLatch.countDown();  
84.     }  
85.   
86.     public CountDownLatch getCountDownLatch() {  
87.         return countDownLatch;  
88.     }  
89.   
90.     public void setCountDownLatch(CountDownLatch countDownLatch) {  
91.         this.countDownLatch = countDownLatch;  
92.     }  
93.   
94.     public String getMark() {  
95.         return mark;  
96.     }  
97.   
98.     public void setMark(String mark) {  
99.         this.mark = mark;  
100.     }  
101.   
102. }  

CyclicBarrier 测试类：

[html]  view plain  copy

1. import java.util.concurrent.BrokenBarrierException;  
2. import java.util.concurrent.CyclicBarrier;  
3. import java.util.concurrent.Executor;  
4. import java.util.concurrent.Executors;  
5. /**  
6.  * 测试CyclicBarrier类的使用  
7.  */  
8. public class TestCyclicBarrier {  
9.     static final Integer NUM = 5;  
10.     public static void main(String[] args) throws InterruptedException {  
11.         //实例CyclicBarrier对象  
12.         CyclicBarrier cyclicBarrier = new CyclicBarrier(NUM);  
13.         //实例化一个固定大小线程池  
14.         Executor executor = Executors.newFixedThreadPool(NUM);  
15.         for(int i = 1;i<=NUM;i++){  
16.             //执行线程  
17.             executor.execute(new MyRunnale(cyclicBarrier,i+"号"));  
18.             //为了更好的效果，休眠一秒  
19.             Thread.sleep(1000);  
20.         }  
21.         System.out.println("指令通知完成");  
22.     }  
23. }  
24.   
25.   
26. class MyRunnale implements Runnable{  
27.     private CyclicBarrier cyclicBarrier;  
28.     private String mark;  
29.     public MyRunnale(CyclicBarrier cyclicBarrier,String mark) {  
30.         super();  
31.         this.cyclicBarrier = cyclicBarrier;  
32.         this.mark = mark;  
33.     }  
34.     @Override  
35.     public void run() {  
36.         System.out.println(mark+"进入线程,线程阻塞中...");  
37.         try {  
38.             // barrier的await方法，在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。  
39.             cyclicBarrier.await();  
40.             Thread.sleep(2000);//为了看到更好的效果，线程阻塞两秒  
41.         } catch (InterruptedException e) {  
42.             e.printStackTrace();  
43.         } catch (BrokenBarrierException e) {  
44.             e.printStackTrace();  
45.         }  
46.           
47.         System.out.println(mark+"线程阻塞结束,继续执行...");  
48.           
49.     }  
50.     public CyclicBarrier getCyclicBarrier() {  
51.         return cyclicBarrier;  
52.     }  
53.   
54.     public void setCyclicBarrier(CyclicBarrier cyclicBarrier) {  
55.         this.cyclicBarrier = cyclicBarrier;  
56.     }  
57.   
58. }  

总结:
  

CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。