一、CountDownLatch 初始
CountDownLatch 中 count down 是倒数的意思,latch 则是门闩的含义。整体含义可以理解为倒数的门栓,似乎有一点“三二一,芝麻开门”的感觉。CountDownLatch 的作用也是如此,在构造 CountDownLatch 的时候需要传入一个整数 n,在这个整数“倒数”到 0 之前,主线程需要等待在门口,而这个“倒数”过程则是由各个执行线程驱动的,每个线程执行完一个任务“倒数”一次。总结来说,CountDownLatch 的作用就是等待其他的线程都执行完任务,必要时可以对各个任务的执行结果进行汇总,然后主线程才继续往下执行。
CountDownLatch 主要有两个方法:countDown() 和 await() 。countDown() 方法用于使计数器减一,其一般是执行任务的线程调用,await() 方法则使调用该方法的线程处于等待状态,其一般是主线程调用。这里需要注意的是,countDown() 方法并没有规定一个线程只能调用一次,当同一个线程调用多次 countDown() 方法时,每次都会使计数器减一;另外,await() 方法也并没有规定只能有一个线程执行该方法,如果多个线程同时执行 await() 方法,那么这几个线程都将处于等待状态,并且以共享模式享有同一个锁。如下是其使用示例:
public class CountDownLatchExample {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(5);
Service service = new Service(latch);
Runnable task = () -> service.exec();
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(task);
thread.start();
}
System.out.println("main thread await. ");
latch.await();
System.out.println("main thread finishes await. ");
}
}
public class Service {
private CountDownLatch latch;
public Service(CountDownLatch latch) {
this.latch = latch;
}
public void exec() {
try {
System.out.println(Thread.currentThread().getName() + " execute task. ");
sleep(2);
System.out.println(Thread.currentThread().getName() + " finished task. ");
} finally {
latch.countDown();
}
}
private void sleep(int seconds) {
try {
TimeUnit.SECONDS.sleep(seconds);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
在上面的例子中,首先声明了一个CountDownLatch对象,并且由主线程创建了5个线程,分别执行任务,在每个任务中,当前线程会休眠2秒。在启动线程之后,主线程调用了CountDownLatch.await()方法,此时,主线程将在此处等待创建的5个线程执行完任务之后才继续往下执行。如下是执行结果:
Thread-0 execute task.
Thread-1 execute task.
Thread-2 execute task.
Thread-3 execute task.
Thread-4 execute task.
main thread await.
Thread-0 finished task.
Thread-4 finished task.
Thread-3 finished task.
Thread-1 finished task.
Thread-2 finished task.
main thread finishes await.
从输出结果可以看出,主线程先启动了五个线程,然后主线程进入等待状态,当这五个线程都执行完任务之后主线程才结束了等待。上述代码中需要注意的是,在执行任务的线程中,使用了 try...finally 结构,该结构可以保证创建的线程发生异常时 CountDownLatch.countDown() 方法也会执行,也就保证了主线程不会一直处于等待状态。
二、工作中使用 CountDownLatch 解决问题
1)定义一个线程池
public class ThreadUtils {
private static ExecutorService executor;
static {
/**
* 构建一个线程池
* 获取服务器CPU的核数:Runtime.getRuntime().availableProcessors()
* 线程池定义大小:CPU * 2 + 1
*/
executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors() * 2 + 1,
Runtime.getRuntime().availableProcessors() * 2 + 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue(10000));
}
/**
* 线程池中线程执行任务
*/
public static void execute(Runnable task) {
executor.execute(task);
}
}
2)线程池结合 CountDownLatch 进行任务分批并行处理
/**
* 模拟线程池分批处理任务,主线程需要等待子任务线程执行完,结果汇总之后,主线程继续往下执行
*/
public void handleLogin(List<String> paramList) {
// 使用线程池中线程分批处理业务逻辑,并行处理任务提高终端响应速度
CountDownLatch latch = new CountDownLatch(paramList.size());
for (String param : paramList) {
ThreadUtils.execute(() -> {
try {
log.info("业务逻辑处理,参数:{}", param);
// 业务逻辑正常处理......
} catch (Exception e) {
log.error("调用下游系统出现错误,异常逻辑处理......");
} finally {
// 业务逻辑处理完毕,计数器减一【当前线程处理任务完毕,线程释放进入线程池,等待处理下一个任务】
latch.countDown();
}
});
}
// 主线程需要等待子任务线程执行完,结果汇总之后,主线程继续往下执行
try {
latch.await();
} catch (Exception e) {
log.error("等待超时", e);
throw new RuntimeException("系统处理超时,请稍后再试");
}
}
三、CountDownLatch 使用场景
场景一:CountDownLatch 非常适合于对任务进行拆分,使其并行执行,比如某个任务执行2s,其对数据的请求可以分为五个部分,那么就可以将这个任务拆分为5个子任务,分别交由五个线程执行,执行完成之后再由主线程进行汇总,此时,总的执行时间将决定于执行最慢的任务,平均来看,还是大大减少了总的执行时间。
场景二:使用 CountDownLatch 的地方是使用某些外部链接请求数据的时候,比如图片。在本人所从事的项目中就有类似的情况,因为我们使用的图片服务只提供了获取单个图片的功能,而每次获取图片的时间不等,一般都需要1.5s~2s。当我们需要批量获取图片的时候,比如列表页需要展示一系列的图片,如果使用单个线程顺序获取,那么等待时间将会极长,此时我们就可以使用CountDownLatch对获取图片的操作进行拆分,并行的获取图片,这样也就缩短了总的获取时间。