多线程计数器:countdowlatch 和 cyclicbarrier 的内部原理和用法

例子

1.CountDownLatch：多线程计数器（减计数），初始值代表需要首先执行完成的线程个数，当CountDownLatch countDown（不阻塞线程）为0时，被阻塞（await）的线程才会被唤醒。一个线程等待其他多个线程完成一件事，才可以继续执行。只能使用一次。应用启动时，主线程等待其他线程执行完成。

2.CyclicBarrier：多线程计数器（加计数），初始值代表需要首先执行完成的线程个数。线程之间相互等待，当所有线程都await之后，这些线程才可以继续执行。可以重复使用（reset）。

异同点：

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();//线程数减少
        }
    }

}

输出: 

ready !
ready !
ready !
ready !
judge say : run !
arrived !
arrived !
arrived !
arrived !
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也将迅速返回。

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

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个线程，他们之间任何一个没有完成，所有的线程都必须等待。

 

 

-------------------------------下半部分-----------------------------------------------------------------------

 

 

CountDownLatch	CyclicBarrier
减计数方式	加计数方式
计算为0时释放所有等待的线程	计数达到指定值时释放所有等待线程
计数为0时，无法重置	计数达到指定值时，计数置为0重新开始
调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响	调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞
不可重复利用	可重复利用

   

模拟启动3000 个线程，同时并发执行并统计所有线程执行完成后所消耗的时间。代码:

package com.single;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

public class ThreadHttps {

    public static void main(String[] args) {

        try {
            long start = System.currentTimeMillis();
            CountDownLatch startlatch = new CountDownLatch(300);//需要等待启动多少个线程
            CountDownLatch endlatch = new CountDownLatch(300);//需要等待多少个线程完成后
            for (int i = 0; i < 300; i++) {
                Map<String, String> map = new HashMap<String, String>();
                //启动俩个线程，都去调用BS20102
                MyThread myThread1 = new MyThread("" + i, map, startlatch, endlatch);
                myThread1.start();
                startlatch.countDown();
            }
            endlatch.await();//等待所有工人完成工作  若endlatch不为0 则堵塞，若为0 则运行继续执行
            long end = System.currentTimeMillis();
            System.out.println("所有工作都完成消耗的时间：" + (end - start) + "毫秒");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static class MyThread extends Thread {
        private String tradeType;
        private Map<String, String> map;
        private CountDownLatch startlatch;
        private CountDownLatch endlatch;

        public MyThread(String tradeType, Map<String, String> map, CountDownLatch startlatch, CountDownLatch endlatch) {
            this.tradeType = tradeType;
            this.map = map;
            this.startlatch = startlatch;
            this.endlatch = endlatch;
        }

        public void run() {

            System.out.println("latch.getCount:" + startlatch.getCount());

            try {
                while (startlatch.getCount() != 0) {

                    Thread.sleep(10);
                }
                long start = System.currentTimeMillis();
                System.out.println("tradeType：" + tradeType + ",~~~开始执行~~~");
                Thread.sleep(3000);
                long end = System.currentTimeMillis();
                System.out.println("tradeType:" + tradeType + " ,线程消耗时间" + (end - start));

                endlatch.countDown();//线程内容执行完成后，计数器减一
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

CountDownLatch的用法：

      CountDownLatch典型用法1：某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为n new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

       CountDownLatch典型用法2：实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计数器初始化为1，多个线程在开始执行任务前首先 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。

在实时系统中的使用场景：

1.实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用 一次countDown()方法就可以让所有的等待线程同时恢复执行。

2.开始执行前等待n个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。

3.死锁检测：一个非常方便的使用场景是，你可以使用n个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。

4.用CountDownLatch模拟10人参加跑步比赛的过程。

   ①service 模拟跑步：

public class Service {
    public void testMethod() {
        try {
            System.out.println(Thread.currentThread().getName() + " begin timer " + System.currentTimeMillis());
            Thread.sleep((long) (Math.random()*10000));//模拟每个跑步选手跑完100米所需的时间
            System.out.println(Thread.currentThread().getName() + " end timer " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

 ②MyThread（模拟一名参赛选手）：

import java.util.concurrent.CountDownLatch;

public class MyThread extends Thread {

    private Service service;
    private final CountDownLatch begin;
    private final CountDownLatch end;


    public MyThread(Service service, CountDownLatch begin, CountDownLatch end){
        this.service = service;
        this.begin  = begin;
        this.end  = end;
    }

    public void run(){
        try {
            begin.await();//每个参赛选手都站在自己的跑道上，做好了比赛的准备，正在等裁判鸣枪开始比赛
            service.testMethod();//听到鸣枪后比赛开始了
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            end.countDown();//其中的一个参赛选手已经跑完了
        }

    }

}

  ③CountDownLatchDemo（模拟整个跑步比赛场景）：

import java.util.concurrent.CountDownLatch;

public class CountDownDemo {

    public static void main(String[] args) {
        try {
            Service service = new Service();
            CountDownLatch begin = new CountDownLatch(1);//裁判员鸣枪信号
            CountDownLatch end = new CountDownLatch(10);//10名参赛选手结束信号
            MyThread[] threadArray = new MyThread[10];
            for(int i = 0 ; i < 10; i++){
                threadArray[i] = new MyThread(service,begin,end);
                threadArray[i].setName((i + 1) + " 号选手 ");
                threadArray[i].start();
            }
            System.out.println("在等待裁判员鸣枪  " + System.currentTimeMillis());
            long t1 = System.currentTimeMillis();//记录比赛的开始时间
            begin.countDown();//裁判员鸣枪了
            end.await();//等待10个参赛选手都跑完100米
            long t2 = System.currentTimeMillis();//记录比赛的结束时间
            System.out.println("所有参赛选手都完成了100米赛跑，赛跑总耗时是  " + (t2-t1));
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

转自:简简单单1111