java 并发之（一）同步器（synchronizer）CountDownLatch、CyclicBarrier、Semaphore

 

来自：http://janeky.iteye.com/blog/769965

 

Java1.5提供了一个非常高效实用的多线程包：java.util.concurrent, 提供了大量高级工具，可以帮助开发者编写高效、易维护、结构清晰的Java多线程程序。从这篇blog起，我将跟大家一起共同学习这些新的Java多线程构件 

1. CountDownLatch （闭锁-倒数的锁）
    我们先来学习一下JDK1.5 API中关于这个类的详细介绍： 
“一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。” 

    这就是说，CountDownLatch可以用来管理一组相关的线程执行，只需在主线程中调用CountDownLatch 的await方法（一直阻塞），让各个线程调用countDown方法。当所有的线程都只需完countDown了，await也顺利返回，不再阻塞了。在这样情况下尤其适用：将一个任务分成若干线程执行，等到所有线程执行完，再进行汇总处理。 

 

API：方法有await()、await(long timeout, TimeUnit unit)、countDown()、getCount()

    下面我举一个非常简单的例子。假设我们要打印1-100，最后再输出“Ok“。1-100的打印顺序不要求统一，只需保证“Ok“是在最后出现即可。 

    解决方案：我们定义一个CountDownLatch，然后开10个线程分别打印（n-1）*10+1至（n-1）*10+10。主线程中调用await方法等待所有线程的执行完毕，每个线程执行完毕后都调用countDown方法。最后再await返回后打印“Ok”。 

具体代码如下（本代码参考了JDK示例代码）： 

Java代码  

1. import java.util.concurrent.CountDownLatch;  
2. /** 
3.  * 示例：CountDownLatch的使用举例 
4.  * Mail: ken@iamcoding.com 
5.  * @author janeky 
6.  */  
7. public class TestCountDownLatch {  
8.     private static final int N = 10;  
9.   
10.     public static void main(String[] args) throws InterruptedException {  
11.         CountDownLatch doneSignal = new CountDownLatch(N);  
12.         CountDownLatch startSignal = new CountDownLatch(1);//开始执行信号  
13.   
14.         for (int i = 1; i <= N; i++) {  
15.             new Thread(new Worker(i, doneSignal, startSignal)).start();//线程启动了  
16.         }  
17.         System.out.println("begin------------");  
18.         startSignal.countDown();//开始执行啦  
19.         doneSignal.await();//等待所有的线程执行完毕  
20.         System.out.println("Ok");  
21.   
22.     }  
23.   
24.     static class Worker implements Runnable {  
25.         private final CountDownLatch doneSignal;  
26.         private final CountDownLatch startSignal;  
27.         private int beginIndex;  
28.   
29.         Worker(int beginIndex, CountDownLatch doneSignal,  
30.                 CountDownLatch startSignal) {  
31.             this.startSignal = startSignal;  
32.             this.beginIndex = beginIndex;  
33.             this.doneSignal = doneSignal;  
34.         }  
35.   
36.         public void run() {  
37.             try {  
38.                 startSignal.await(); //等待开始执行信号的发布  
39.                 beginIndex = (beginIndex - 1) * 10 + 1;  
40.                 for (int i = beginIndex; i <= beginIndex + 10; i++) {  
41.                     System.out.println(i);  
42.                 }  
43.             } catch (InterruptedException e) {  
44.                 e.printStackTrace();  
45.             } finally {  
46.                 doneSignal.countDown();  
47.             }  
48.         }  
49.     }  
50. }  

    总结：CounDownLatch对于管理一组相关线程非常有用。上述示例代码中就形象地描述了两种使用情况。第一种是计算器为1，代表了两种状态，开关。（在netty框架socket客户端使用：客户端向服务端写数据之后，需要等待服务端的返回。用法：等待 countDownLatch.await(timeOut, TimeUnit.MILLISECONDS)，唤醒countDownLatch.countDown()）

第二种是计数器为N，代表等待N个操作完成。今后我们在编写多线程程序时，可以使用这个构件来管理一组独立线程的执行。 

2. CyclicBarrier （循环的栅栏）
    我们先来学习一下JDK1.5 API中关于这个类的详细介绍： 
    “一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。 
    CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作 很有用。 

    我们在学习CountDownLatch的时候就提到了CyclicBarrier。两者究竟有什么联系呢？引用[JCIP]中的描述“The key difference is that with a barrier, all the threads must come together at a barrier point at the same time in order to proceed. Latches are for waiting for events; barriers are for waiting for other threads。CyclicBarrier等待所有的线程一起完成后再执行某个动作。这个功能CountDownLatch也同样可以实现。但是CountDownLatch更多时候是在等待某个事件的发生。在CyclicBarrier中，所有的线程调用await方法，等待其他线程都执行完。 

 

API：构造函数CyclicBarrier(int parties, Runnable barrierAction)、CyclicBarrier(int parties)

方法：await(long timeout, TimeUnit unit)、await()

    举一个很简单的例子，今天晚上我们哥们4个去Happy。就互相通知了一下：晚上八点准时到xx酒吧门前集合，不见不散！。有个哥们住的近，早早就到了。有的事务繁忙，刚好踩点到了。无论怎样，先来的都不能独自行动，只能等待所有人 

代码如下（参考了网上给的一些教程） 

Java代码  

1. import java.util.Random;  
2. import java.util.concurrent.BrokenBarrierException;  
3. import java.util.concurrent.CyclicBarrier;  
4. import java.util.concurrent.ExecutorService;  
5. import java.util.concurrent.Executors;  
6.   
7. public class TestCyclicBarrier {  
8.   
9.     public static void main(String[] args) {  
10.       
11.         ExecutorService exec = Executors.newCachedThreadPool();       
12.         final Random random=new Random();  
13.           
14.         final CyclicBarrier barrier=new CyclicBarrier(4,new Runnable(){  
15.             @Override  
16.             public void run() {  
17.                 System.out.println("大家都到齐了，开始happy去");  
18.             }});  
19.           
20.         for(int i=0;i<4;i++){  
21.             exec.execute(new Runnable(){  
22.                 @Override  
23.                 public void run() {  
24.                     try {  
25.                         Thread.sleep(random.nextInt(1000));  
26.                     } catch (InterruptedException e) {  
27.                         e.printStackTrace();  
28.                     }  
29.                     System.out.println(Thread.currentThread().getName()+"到了，其他哥们呢");  
30.                     try {  
31.                         barrier.await();//等待其他哥们  
32.                     } catch (InterruptedException e) {  
33.                         e.printStackTrace();  
34.                     } catch (BrokenBarrierException e) {  
35.                         e.printStackTrace();  
36.                     }  
37.                 }});  
38.         }  
39.         exec.shutdown();  
40.     }  
41.   
42. }  

    关于await方法要特别注意一下，它有可能在阻塞的过程中由于某些原因被中断 

    总结：CyclicBarrier就是一个栅栏，等待所有线程到达后再执行相关的操作。barrier 在释放等待线程后可以重用。

 

 

 

3. Semaphore 
    我们先来学习一下JDK1.5 API中关于这个类的详细介绍： 
“一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。” 

 

 

 

将信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：一个可用的许可，或零个可用的许可。按此方式使用时，二进制信号量具有某种属性（与很多 Lock 实现不同），即可以由线程释放“锁”，而不是由所有者（因为信号量没有所有权的概念）。在某些专门的上下文（如死锁恢复）中这会很有用。

    我们一般用它来控制某个对象的线程访问对象 

    例如，对于某个容器，我们规定，最多只能容纳n个线程同时操作 
使用信号量来模拟实现 

具体代码如下（参考 [JCIP]） 

 

Java代码  

1. import java.util.Collections;  
2. import java.util.HashSet;  
3. import java.util.Set;  
4. import java.util.concurrent.ExecutorService;  
5. import java.util.concurrent.Executors;  
6. import java.util.concurrent.Semaphore;  
7.   
8. public class TestSemaphore {  
9.   
10.     public static void main(String[] args) {  
11.         ExecutorService exec = Executors.newCachedThreadPool();  
12.         TestSemaphore t = new TestSemaphore();  
13.         final BoundedHashSet<String> set = t.getSet();  
14.   
15.         for (int i = 0; i < 3; i++) {//三个线程同时操作add  
16.             exec.execute(new Runnable() {  
17.                 public void run() {  
18.                     try {  
19.                         set.add(Thread.currentThread().getName());  
20.                     } catch (InterruptedException e) {  
21.                         e.printStackTrace();  
22.                     }  
23.                 }  
24.             });  
25.         }  
26.   
27.         for (int j = 0; j < 3; j++) {//三个线程同时操作remove  
28.             exec.execute(new Runnable() {  
29.                 public void run() {  
30.                     set.remove(Thread.currentThread().getName());  
31.                 }  
32.             });  
33.         }  
34.         exec.shutdown();  
35.     }  
36.   
37.     public BoundedHashSet<String> getSet() {  
38.         return new BoundedHashSet<String>(2);//定义一个边界约束为2的线程  
39.     }  
40.   
41.     class BoundedHashSet<T> {  
42.         private final Set<T> set;  
43.         private final Semaphore semaphore;  
44.   
45.         public BoundedHashSet(int bound) {  
46.             this.set = Collections.synchronizedSet(new HashSet<T>());  
47.             this.semaphore = new Semaphore(bound, true);  
48.         }  
49.   
50.         public void add(T o) throws InterruptedException {  
51.             semaphore.acquire();//信号量控制可访问的线程数目  
52.             set.add(o);  
53.             System.out.printf("add:%s%n",o);  
54.         }  
55.   
56.         public void remove(T o) {  
57.             if (set.remove(o))  
58.                 semaphore.release();//释放掉信号量  
59.             System.out.printf("remove:%s%n",o);  
60.         }  
61.     }  
62. }  

    总结：Semaphore通常用于对象池的控制 （使用其对HTTP线程池的线程数进行控制）