cyclicbarrier与countdownlatch

自我记录自我记录。。

CyclicBarrier与CountDownLatch，两个都是用来控制线程同步，两者的给我感觉最大的区别：
CountDownLatch好比是多人打LOL，所有人准备好才开，但是如果你准备好了（latch.countDown()），你还可以做其他的事情（可以执行latch.countDown()之后的语句），比如喝水啊，削铅笔啊，这个均不受影响
CyclicBarrier这个好比赛跑，在起跑线准备的时候，大家都是神经紧绷（barrier.await()），几秒钟时间内，基本上除了全神贯注做准备动作之外，都没有精力做其他的事情（（barrier.await()）后面的语句不会执行）
barrier：障碍，障碍，障碍， 遇到障碍了，自然不能往前走了
CyclicBarrier模拟代码：

public class MyCyclicBarrier {

    public static void main(String[] args) {
        //有两种初始化方式
        //1、 new CyclicBarrier(5)
        //2、 new CyclicBarrier(5, new Runnable() { ... });
        //第2中，只有在所有线程准备完之后，执行new Runnable中的run方法
        CyclicBarrier barrier = new CyclicBarrier(5, new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub <br>
                System.out.println("开跑！");
            }
        });
        //这里的线程大小需要设置为与CyclicBarrier的初始化大小一致，如果小于初始化大小，那么会一直等下去，如果大于初始化大小，那么会有线程一直处在等待状态
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread("选手" + i, barrier));
        }


    }

    static class MyThread extends Thread {

        private CyclicBarrier barrier;
        private String threadName;
        public MyThread(String threadName, CyclicBarrier barrier) {
            this.threadName = threadName;
            this.barrier = barrier;
        }

        @Override
        public void run() {

            System.out.println(this.threadName + "就位，时间："  + System.currentTimeMillis());
            try {

                Thread.sleep(new Random().nextInt(4000));

                System.out.println(this.threadName + "等待其他选手就位！" + System.currentTimeMillis());
                //如果把上面这句放到barrier.await()后面，那么得到的System.currentTimeMillis()结果是是一样的，由此可见，在barrier.await()后面的语句会在所有线程均准备之后再同时执行！（可以这么理解：barrier把后面的语句都挡住了，除非线程都准备好了一起破除障碍，否则都别想过去）
                barrier.await();

                System.out.println("所有选手均已就位！！！");
            }
            catch (InterruptedException e) {
                // TODO Auto-generated catch block <br>
                e.printStackTrace();
            }
            catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block <br>
                e.printStackTrace();
            }



        }

    }

} 

CountDownLatch代码：

public class MyCountDownLatch {

    public static void main(String[] args) {
      //声明需要几个线程等待
        CountDownLatch latch = new CountDownLatch(5);
        //这个跟上面的一样的道理，如果线程大小大于5，那么多的那些线程会一直等，如果小于5，那么大家都一起等着吧
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread("MyThread" + i, latch));
        }
        try {
            latch.await();
        }
        catch (InterruptedException e) {
            // TODO Auto-generated catch block <br>
            e.printStackTrace();
        }

        System.out.println("到点，开考！！");

    }

    static class MyThread extends Thread {
        private CountDownLatch latch ;
        private String threadName;

        public MyThread (String threadName, CountDownLatch latch) {
            this.threadName = threadName;
            this.latch = latch;
        }

        @Override
        public void run() {
            System.out.println(this.threadName + " 准备考试。。。" + System.currentTimeMillis());

            try {
                Thread.sleep(new Random().nextInt(3000));
            }
            catch (InterruptedException e) {
                // TODO Auto-generated catch block <br>
                e.printStackTrace();
            }

            latch.countDown();
            //准备完之后，还可以喝喝水，聊聊天，削铅笔啥的
            System.out.println(this.threadName + " 等着开考！" + System.currentTimeMillis());
        }

    }

}

大致就是这样了。。 留着以后看