java多线程学习-java.util.concurrent详解(一) Latch/Barrier

 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;
 /**
  * 示例：CountDownLatch的使用举例
  * Mail: ken@iamcoding.com
  * @author janeky
  */
 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();
             }
         }
     }
 }

    总结：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方法要特别注意一下，它有可能在阻塞的过程当中因为某些缘由被中断 

    总结：CyclicBarrier就是一个栅栏，等待全部线程到达后再执行相关的操做。barrier 在释放等待线程后能够重用。