java 多线程之CountDownLatch

 介绍

• CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待直到其他线程执行完毕才开始执行。
• 用给定的计数初始化CountDownLatch，其含义是需要等待多少个线程次数执行完再开始执行。
• 不论哪个线程，只要每次调用CountDown()，其计数都会减1，即需要等待的执行次数减1.

主程序执行到await()函数会进入阻塞状态(等待)，等待线程的执行，直到计数为0，恢复正常态。

实现原理

CountDownLatch是通过一个计数器来实现的，计数器的初始化值为需要等待的线程执行次数。每当一个线程完成了自己的任务后，计数器的值就相应的减1。当计数器到达0时，表示所有的线程都已完成任务，然后在闭锁上等待的线程就可以恢复执行任务(继续执行任务)。

说明

• CountDownLatch end = new CountDownLatch(N);
  • 表示构建一个为N的计数器，也即闭锁需要等待的线程数量
• end.await()  能够阻塞当前线程的执行，直到调用N次countDown()之后，被阻塞的线程才继续执行
• end.countDown()：可以在多个线程中调用 ，表示递减锁存器的计数，如果计数到达零，则释放被阻塞的线程
• getCount()：获取锁存器的计数值

示例-1

package cc.kgc.controller;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchTest {
    private static final int RUNNER_COUNT = 10;//参赛人数
    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch begin = new CountDownLatch(3);//初始化等待数量 1
        final CountDownLatch end = new CountDownLatch(RUNNER_COUNT);//初始化等待数量 10
        final ExecutorService exec = Executors.newFixedThreadPool(1);//创建可重用的线程池-10个线程

        for (int i = 0; i < RUNNER_COUNT; i++) {
            int NO = i + 1;
            //定义需执行的线程任务
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep((long)(Math.random() * 1000));//睡眠1s
                        System.out.println("No." + NO + " arrived");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        begin.countDown();
//                        System.out.println(begin.getCount());
                    }
                }
            };
            exec.submit(run);//执行任务
        }

        System.out.println("Game Start ...");
        begin.await();//主线程执行到此处进入阻塞，等待其它线程(子线程)执行完毕
//        end.await();
//        end.await(30, TimeUnit.SECONDS);
        System.out.println("Game Over.");//其它线程执行完毕，主线程继续执行

        exec.shutdown();
    }
}

我们可以修改当前线程池中的数量，然后执行，其结果都类似于下面，也就是说，3次线程任务执行完以后，被阻塞的线程才得以释放。

示例-2

package cc.kgc.controller;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchTest {
    private static final int RUNNER_COUNT = 10;//参赛人数
    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch begin = new CountDownLatch(3);//初始化等待数量 1
        final CountDownLatch end = new CountDownLatch(RUNNER_COUNT);//初始化等待数量 10
        final ExecutorService exec = Executors.newFixedThreadPool(10);//创建可重用的线程池-10个线程

        for (int i = 0; i < RUNNER_COUNT; i++) {
            int NO = i + 1;
            //定义需执行的线程任务
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep((long)(Math.random() * 1000));//睡眠1s
                        System.out.println("No." + NO + " arrived");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        begin.countDown();
//                        System.out.println(begin.getCount());
                    }
                }
            };
            exec.submit(run);//执行任务
        }

        System.out.println("Game Start ...");
//        begin.await();//主线程执行到此处进入阻塞，等待其它线程(子线程)执行完毕
        end.await();
//        end.await(30, TimeUnit.SECONDS);
        System.out.println("Game Over.");//其它线程执行完毕，主线程继续执行

        exec.shutdown();
    }
}

我们发现，当基于计数器的await()方法被调用时，当前主线程一直被阻塞，等待计数器的归零。只有等到计数器归零的一刻，被阻塞的线程才继续执行，否则一直处于等待状态。注意，调用次数是基于计数器而言的，比如这里的end.await()针对的就是end计数器，每次递减需通过end.countDown()。

线程池-shutdown方法

shutdown只是将线程池的状态设置为SHUTWDOWN状态，正在执行的任务会继续执行下去，没有被执行的则中断。而shutdownNow则是将线程池的状态设置为STOP，正在执行的任务会被停止，没被执行任务的则返回。