countdowlatch 和 cyclicbarrier 的内部原理和用法

http://www.wtoutiao.com/p/1b4Lvvv.html

http://www.jb51.net/article/34729.htm

http://blog.csdn.net/lantian0802/article/details/9720993

http://aaron-han.iteye.com/blog/1591755

例子

1.CountDownLatch减计数，CyclicBarrier加计数。
2.CountDownLatch是一次性的，CyclicBarrier可以重用。

 

1、CountDownLatch

一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。

 

 

用法：用给定的计数初始化CountDownLath。调用countDown()方法计数减 1，在计数被减到 0之前，调用await方法会一直阻塞。减为 0之后，则会迅速释放所有阻塞等待的线程，并且调用await操作会立即返回。

ps：CountDownLath计数无法被重置，如果需要重置计数，请考虑使用CyclicBarrier.

有五个人，一个裁判。这五个人同时跑，裁判开始计时，五个人都到终点了，裁判喊停，然后统计这五个人从开始跑到最后一个撞线用了多长时间。

    import java.util.concurrent.CountDownLatch;  
      
    public class Race {  
      
        public static void main(String[] args) {  
            final int num = 5;  
            final CountDownLatch begin = new CountDownLatch(1);  
            final CountDownLatch end = new CountDownLatch(num);  
      
            for (int i = 0; i < num; i++) {  
                new Thread(new AWorker(i, begin, end)).start();  
            }  
      
            // judge prepare...  
            try {  
                Thread.sleep((long) (Math.random() * 5000));  
            } catch (InterruptedException e1) {  
                e1.printStackTrace();  
            }  
      
            System.out.println("judge say : run !");  
            begin.countDown();  
            long startTime = System.currentTimeMillis();  
      
            try {  
                end.await();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } finally {  
                long endTime = System.currentTimeMillis();  
                System.out.println("judge say : all arrived !");  
                System.out.println("spend time: " + (endTime - startTime));  
            }  
      
        }  
      
    }  
      
    class AWorker implements Runnable {  
        final CountDownLatch begin;  
        final CountDownLatch end;  
        final int id;  
      
        public AWorker(final int id, final CountDownLatch begin,  
                final CountDownLatch end) {  
            this.id = id;  
            this.begin = begin;  
            this.end = end;  
        }  
      
        @Override  
        public void run() {  
            try {  
                System.out.println(this.id + " ready !");  
                begin.await();  
                // run...  
                Thread.sleep((long) (Math.random() * 10000));  
            } catch (Throwable e) {  
                e.printStackTrace();  
            } finally {  
                System.out.println(this.id + " arrived !");  
                end.countDown();  
            }  
        }  
      
    }  

输出：

4 ready !
1 ready !
3 ready !
2 ready !
judge say : run !
1 arrived !
4 arrived !
0 arrived !
2 arrived !
3 arrived !
judge say : all arrived !
spend time: 9636

CountDownLatch强调的是一个线程（或多个）需要等待另外的n个线程干完某件事情之后才能继续执行。 上述例子，main线程是裁判，5个AWorker是跑步的。运动员先准备，裁判喊跑，运动员才开始跑（这是第一次同步，对应begin）。5个人谁跑到终点了，countdown一下，直到5个人全部到达，裁判喊停（这是第二次同步，对应end），然后算时间。

 

2、使用cyclicbarrier

定义：是一个同步辅助类，它允许一组线程互相等待，直到到达某个公共的屏障点，所有线程一起继续执行或者返回。一个特性就是CyclicBarrier支持一个可选的Runnable命令，在一组线程中的最后一个线程到达之后，该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新此共享状态，此屏障操作很有用。

用法：用计数 N 初始化CyclicBarrier, 每调用一次await，线程阻塞，并且计数+1（计数起始是0），当计数增长到指定计数N时，所有阻塞线程会被唤醒。继续调用await也将迅速返回。

规定五个人只要都跑到终点了，大家可以喝啤酒。但是，只要有一个人没到终点，就不能喝。 这里也没有要求大家要同时起跑

    import java.util.concurrent.BrokenBarrierException;  
    import java.util.concurrent.CyclicBarrier;  
      
    public class Beer {  
      
        public static void main(String[] args) {  
            final int count = 5;  
            final CyclicBarrier barrier = new CyclicBarrier(count, new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println("drink beer!");  
                }  
            });  
      
            // they do not have to start at the same time...  
            for (int i = 0; i < count; i++) {  
                new Thread(new Worker(i, barrier)).start();  
            }  
        }  
      
    }  
      
    class Worker implements Runnable {  
        final int id;  
        final CyclicBarrier barrier;  
      
        public Worker(final int id, final CyclicBarrier barrier) {  
            this.id = id;  
            this.barrier = barrier;  
        }  
      
        @Override  
        public void run() {  
            try {  
                System.out.println(this.id + "starts to run !");  
                Thread.sleep((long) (Math.random() * 10000));  
                System.out.println(this.id + "arrived !");  
                this.barrier.await();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (BrokenBarrierException e) {  
                e.printStackTrace();  
            }  
        }  
    }  

输出：

0starts to run !
2starts to run !
1starts to run !
3starts to run !
4starts to run !
1arrived !
3arrived !
2arrived !
0arrived !
4arrived !
drink beer!

CyclicBarrier强调的是n个线程，大家相互等待，只要有一个没完成，所有人都得等着。正如上例，只有5个人全部跑到终点，大家才能开喝，否则只能全等着。

 

这样应该就清楚一点了，对于CountDownLatch来说，重点是那个“一个线程”, 是它在等待， 而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。