CountDownLatch使用详解

发布时间：2023-05-20

CountDownLatch是Java并发包中常用的工具类之一，用于实现线程同步，控制线程的执行顺序和协调多个线程之间的操作。CountDownLatch的使用可以在多种情景下发挥作用，如：如果一个主线程（或者一个线程）要等待多个子线程完成并且汇总所有结果之后再继续执行，那么可以使用CountDownLatch来实现。

一、CountDownLatch简介

CountDownLatch是Java并发包中提供的一个同步工具类，被广泛用于多线程并发编程中。它的主要作用是允许一个线程等待一组线程执行完毕后再继续执行。CountDownLatch内部维护了一个计数器，计数器的初始值为一个正整数，当一个线程执行完毕时，计数器的值减1。当计数器的值降为0时，主线程（或者一组线程）被唤醒，继续执行后面的流程。 CountDownLatch主要有两个方法：countDown()和await()。countDown()方法用于将CountDownLatch的计数器减1，await()方法用于阻塞主线程或者一组线程，直到计数器的值降为0。 下面是一个使用CountDownLatch计算1~10的和的例子：

import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        int n = 10;
        CountDownLatch latch = new CountDownLatch(n);
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            final int num = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is running...");
                sum += num;
                latch.countDown();
            }, "Thread-" + i).start();
        }
        latch.await();
        System.out.println("Sum of 1~10 is " + sum);
    }
}

执行结果如下：

Thread-1 is running...
Thread-2 is running...
Thread-3 is running...
Thread-4 is running...
Thread-5 is running...
Thread-6 is running...
Thread-7 is running...
Thread-8 is running...
Thread-9 is running...
Thread-10 is running...
Sum of 1~10 is 55

二、CountDownLatch不生效的情况

在使用CountDownLatch的过程中，有时候会遇到计数器值无法降为0的情况，这里介绍一些CountDownLatch不生效的情况：

  1. 计数器的值被错误设置为了0，导致等待线程无法正确计数。
  2. 计数器的值被线程错误的重置了，导致等待线程的等待时间大于CountDownLatch计数器的减少时间。
  3. 使用CountDownLatch的线程太少，无法减少计数器的值，导致等待线程一直在等待。
  4. 在计数器的值被减少为0之前，等待线程线程被意外唤醒，导致程序提前退出。

三、Countdown死亡倒计时下载

Countdown死亡倒计时下载是指当下载一个文件时，如果网络异常或者其他原因导致下载停止，那么可以使用CountDownLatch来实现下载死亡倒计时，如果下载的时间超过了设置的时间，则自动中断下载。 下面是一个使用CountDownLatch实现下载死亡倒计时的例子：

import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.net.URL;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class DownloadDemo {
    public static void main(String[] args) {
        String url = "http://example.com/example.txt";
        String file = "example.txt";
        int timeout = 5000;
        download(url, file, timeout);
    }
    public static void download(String url, String file, int timeout) {
        CountDownLatch latch = new CountDownLatch(1);
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        executorService.execute(() -> {
            try (BufferedInputStream bis = new BufferedInputStream(new URL(url).openConnection().getInputStream());
                 FileOutputStream fos = new FileOutputStream(file)) {
                byte[] buffer = new byte[1024];
                int len;
                while ((len = bis.read(buffer)) != -1) {
                    fos.write(buffer, 0, len);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                latch.countDown();
            }
        });
        try {
            boolean isSuccess = latch.await(timeout, TimeUnit.MILLISECONDS);
            if (!isSuccess) {
                System.out.println("Download timeout, cancel download.");
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

在以上代码中，我们使用一个线程池来执行文件下载任务，下载完成后，通过latch.countDown()来表示下载任务已完成。然后在主线程中通过latch.await(timeout, TimeUnit.MILLISECONDS)来等待下载任务完成。如果等待时间超过了设置的超时时间timeout，则自动中断下载任务，释放资源。

推荐文章