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

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

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

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

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

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


import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {
 private static final int N = 10;

 public static void main(String[] args) throws InterruptedException {
  CountDownLatch doneSignal = new CountDownLatch(N);
  CountDownLatch startSignal = new CountDownLatch(1);//开始执行信号

  for (int i = 1; i <= N; i++) {
   new Thread(new Worker(i, doneSignal, startSignal)).start();//线程启动了
  }
  System.out.println("begin------------");
  startSignal.countDown();//开始执行啦
  doneSignal.await();//等待所有的线程执行完毕
  System.out.println("Ok");

 }

 static class Worker implements Runnable {
  private final CountDownLatch doneSignal;
  private final CountDownLatch startSignal;
  private int beginIndex;

  Worker(int beginIndex, CountDownLatch doneSignal,
    CountDownLatch startSignal) {
   this.startSignal = startSignal;
   this.beginIndex = beginIndex;
   this.doneSignal = doneSignal;
  }

  public void run() {
   try {
    startSignal.await(); //等待开始执行信号的发布
    beginIndex = (beginIndex - 1) * 10 + 1;
    for (int i = beginIndex; i <= beginIndex + 10; i++) {
     System.out.println(i);
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   } finally {
    doneSignal.countDown();
   }
  }
 }
}

 

public class CountDownLatchTest {    // 模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。
    public static void main(String[] args) throws InterruptedException {        // 开始的倒数锁 
        final CountDownLatch begin = new CountDownLatch(1);  

        // 结束的倒数锁 
        final CountDownLatch end = new CountDownLatch(10);  

        // 十名选手 
        final ExecutorService exec = Executors.newFixedThreadPool(10);  

        for (int index = 0; index < 10; index++) {            final int NO = index + 1;  
            Runnable run = new Runnable() {                public void run() {  
                    try {  
                        // 如果当前计数为零，则此方法立即返回。
                        // 等待
                        begin.await();  
                        Thread.sleep((long) (Math.random() * 10000));  
                        System.out.println("No." + NO + " arrived");  
                    } catch (InterruptedException e) {  
                    } finally {  
                        // 每个选手到达终点时，end就减一
                        end.countDown();
                    }  
                }  
            };  
            exec.submit(run);
        }  
        System.out.println("Game Start");  
        // begin减一，开始游戏
        begin.countDown();  
        // 等待end变为0，即所有选手到达终点
        end.await();  
        System.out.println("Game Over");  
        exec.shutdown();  
    }
}





package com.woxiaoe.study.thread;

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 模拟项目的开发，只有当每个模块都完成后，项目才完成
 * 每个模块的用时不同
 * @author 小e
 *
 * 2010-4-30 下午07:41:37
 */
class Module implements Runnable{
	private CountDownLatch latch;
	private String moduleName;
	private int time;//用时
	
	

	public Module(CountDownLatch latch, String moduleName,int time) {
		super();
		this.latch = latch;
		this.moduleName = moduleName;
		this.time = time;
	}



	@Override
	public void run() {
		try {
			work();
			latch.countDown();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	private void work() throws InterruptedException{
		TimeUnit.MILLISECONDS.sleep(time);
		System.out.println(moduleName + " 完成，耗时:" + time);
	}
}
class Controller implements Runnable{
	private CountDownLatch latch;

	public Controller(CountDownLatch latch) {
		super();
		this.latch = latch;
	}

	@Override
	public void run() {
		try {
			latch.await();
			System.out.println("所有模块都完成，任务完成");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
}
public class Project {
	static final int SIZE = 20;
	public static void main(String[] args) {
		CountDownLatch latch = new CountDownLatch(SIZE);
		Random r = new Random();
		ExecutorService exec = Executors.newCachedThreadPool();
		Controller controller = new Controller(latch);
		exec.execute(controller);
		for(int i = 0; i < SIZE; i++){
			exec.execute(new Module(latch, "模块" + (i + 1), r.nextInt(2000)));
		}
		
		exec.shutdown();
		
	}

}


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
所有模块都完成，任务完成

 总结：CounDownLatch对于管理一组相关线程非常有用。上述示例代码中就形象地描述了两种使用情况。第一种是计算器为1，代表了两种状态，开关。第二种是计数器为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方法，等待其他线程都执行完。 

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

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

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCyclicBarrier {

 public static void main(String[] args) {
 
  ExecutorService exec = Executors.newCachedThreadPool();    
  final Random random=new Random();
  
  final CyclicBarrier barrier=new CyclicBarrier(4,new Runnable(){
   @Override
   public void run() {
    System.out.println("大家都到齐了，开始happy去");
   }});
  
  for(int i=0;i<4;i++){
   exec.execute(new Runnable(){
    @Override
    public void run() {
     try {
      Thread.sleep(random.nextInt(1000));
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println(Thread.currentThread().getName()+"到了，其他哥们呢");
     try {
      barrier.await();//等待其他哥们
     } catch (InterruptedException e) {
      e.printStackTrace();
     } catch (BrokenBarrierException e) {
      e.printStackTrace();
     }
    }});
  }
  exec.shutdown();
 }

}

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



package com.woxiaoe.study.thread;


import java.util.Random;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;


/**

 * 用java模拟4X100接力赛

 * 当结束后 报成绩，应用CyclicBarrier

 * @author 小e

 *

 * 2010-4-30 下午08:13:40

 */

class Player implements Runnable{

private String name;

private CyclicBarrier barrier;

private Player next;//下一棒

private int time;//用时

private boolean run;//第一棒

public Player(String name, CyclicBarrier barrier, boolean run) {

super();

this.name = name;

this.barrier = barrier;

this.run = run;

}

@Override

public void run() {

try {

synchronized (this) {

while(!run){//等待队员

wait();

}

}

Random r = new Random();

TimeUnit.MILLISECONDS.sleep(r.nextInt(2000));

next(next,11 + r.nextInt(2));

} catch (InterruptedException e) {

e.printStackTrace();

}

}

private void next(Player next, int time) {

System.out.println(name + " 用时：" + time + ",交接棒");

if(next != null){

next.setTime(this.time + time);

synchronized (next) {

next.setRun(true);

next.notify();

}

}else{

System.out.println("跑完，总用时：" + (this.time + time));

}

}

public void setTime(int time) {

this.time = time;

}

public int getTime(){

return this.time;

}

public void setNext(Player next) {

this.next = next;

}

public void setRun(boolean run) {

this.run = run;

}

}

public class RelayRace {

public static void main(String[] args) throws InterruptedException {

final Player[] players = new Player[4];

ExecutorService exec = Executors.newCachedThreadPool();

CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {

@Override

public void run() {

System.out.println("结束，总用时：" + players[3].getTime());

}

});

for(int i = 0; i < 4; i++){

players[i] = new Player("队员" + ( i + 1), barrier, i == 0);

}

for(int i = 0; i < 4; i++){

if( i < 3){

players[i].setNext(players[i + 1]);

exec.execute(players[i]);

}else{

exec.execute(players[3]);

break;

}

}

/*TimeUnit.SECONDS.sleep(3);

* CyclicBarrier 可以重用

for(int i = 0; i < 4; i++){

if( i < 3){

players[i].setNext(players[i + 1]);

exec.execute(players[i]);

}else{

exec.execute(players[3]);

break;

}

}*/

}


}


Output：

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



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