栅栏 CyclicBarrier

java.util.concurrent.CyclicBarrier 类是一种同步机制，它能够对处理一些算法的线程实现同步。换句话讲，它就是一个所有线程必须等待的一个栅栏，直到所有线程都到达这里，然后所有线程才可以继续做其他事情。

package cyclicbarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CyclicBarrier;

public class Total {   
    public static ConcurrentHashMap<String, Integer> result = new ConcurrentHashMap<String, Integer>();   
    public static void main(String[] args) { 
        
        TotalService totalService = new TotalServiceImpl();   
       CyclicBarrier barrier = new CyclicBarrier(5,   
               new TotalTask(totalService));   
        
        // 实际系统是查出所有省编码code的列表，然后循环，每个code生成一个线程。   
        new BillTask(new BillServiceImpl(), barrier, "北京").start();   
        new BillTask(new BillServiceImpl(), barrier, "上海").start();   
        new BillTask(new BillServiceImpl(), barrier, "广西").start();   
        new BillTask(new BillServiceImpl(), barrier, "四川").start();   
        new BillTask(new BillServiceImpl(), barrier, "黑龙江").start();
        
   }   
}   
 
/**  
 * 主任务：汇总任务  
 */  
class TotalTask implements Runnable {   
   private TotalService totalService;   
  
    TotalTask(TotalService totalService) {   
        this.totalService = totalService;   
    }   
  
    public void run() {   
        // 读取内存中各省的数据汇总，过程略。   
        int totalCount = totalService.count();   
        Total.result.put("total", totalCount);
        System.out.println("=======================================");   
        System.out.println("开始全国汇总");  
        System.out.println("全国汇总结果:" +  Total.result.get("total"));
    }   
}   
  
/**  
 * 子任务：计费任务  
 */  
class BillTask extends Thread {   
    // 计费服务   
    private BillService billService;   
    private CyclicBarrier barrier;   
    // 代码，按省代码分类，各省数据库独立。   
    private String code;   
 
    BillTask(BillService billService, CyclicBarrier barrier, String code) {   
        this.billService = billService;   
       this.barrier = barrier;   
       this.code = code;   
    }   
  
    public void run() {   
       System.out.println("开始计算--" + code + "省--数据！");   
        int ret = billService.bill(code); 
        Total.result.put(code, ret);
        // 把bill方法结果存入内存，如ConcurrentHashMap,vector等,代码略   
        System.out.println("结果:" + ret);
        System.out.println(code + "省已经计算完成,并通知汇总Service！");   
       try {   
            // 通知barrier已经完成   
            barrier.await();   
       } catch (InterruptedException e) {   
            e.printStackTrace();   
        } catch (BrokenBarrierException e) {   
            e.printStackTrace();   
       }   
    }   
} 

interface TotalService
{
    public int count();
}

class TotalServiceImpl implements TotalService
{
    @Override
    public int count()
    {
        int totalCount = 0;
        for(String key : Total.result.keySet())
        {
            totalCount += Total.result.get(key);
        }
        return totalCount;
    }
}

interface BillService
{
    public int bill(String code);
}
class BillServiceImpl implements BillService
{

    @Override
    public int bill(String code)
    {
        return 1;
    }
}

原文  http://blog.chinaunix.net/uid-7374279-id-4658408.html