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個線程，他們之間任何一個沒有完成，所有的線程都必須等待。