java并发使用CountDownLatch在生产环境翻车剖析

Java并发使用CountDownLatch在生产环境翻车剖析攻略

什么是CountDownLatch

CountDownLatch 是 java.util.concurrent 包下的一个同步工具类，它可以让一个线程等待一组事件的发生后再继续执行。

CountDownLatch 提供了两个方法：

• countDown()：计数器减一
• await()：等待计数器变为 0

出现的问题

在生产环境中使用 CountDownLatch 时，由于使用不当也可能会出现一些问题，例如：

1. 子线程在等待主线程完成一定操作后才执行，主线程在操作完成后未调用 countDown() 方法导致子线程一直等待下去，出现死锁或长时间占用 CPU 的情况。
2. 子线程调用 countDown() 方法时已经超过了计数器的数量，导致计数器不为 0 而一直等待下去。

如何避免问题

1. 确保主线程调用 countDown() 方法

如果子线程等待主线程完成一定操作后才执行，主线程一定要在操作完成后调用 countDown() 方法。

示例代码：

import java.util.concurrent.CountDownLatch;

public class Demo1 {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);

        new Thread(() -> {
            System.out.println("子线程正在等待...");
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行完成！");
        }).start();

        Thread.sleep(2000);
        System.out.println("主线程执行完成！");
        latch.countDown();
    }
}

在上面的示例中，主线程在 2 秒后执行完成，并调用 countDown() 方法，子线程会等待主线程完成操作后再执行。执行结果如下：

子线程正在等待...
主线程执行完成！
子线程执行完成！

2. 避免超过计数器数量调用 countDown() 方法

如果在子线程调用 countDown() 方法时已经超过了计数器的数量，可以使用 tryAcquireShared(int arg) 方法来判断是否可以继续执行。

示例代码：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;

public class Demo2 {

    private static Semaphore countSemaphore = new Semaphore(1);

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);

        new Thread(() -> {
            System.out.println("子线程1正在执行...");
            latch.countDown();
        }).start();

        new Thread(() -> {
            System.out.println("子线程2正在执行...");
            latch.countDown();
        }).start();

        Thread.sleep(1000);
        if (countSemaphore.tryAcquire()) {
            try {
                System.out.println("主线程正在执行...");
            } finally {
                countSemaphore.release();
            }
            latch.await();
            System.out.println("主线程执行完成！");
        } else {
            System.out.println("主线程等待超时！");
        }
    }
}

在上面的示例中，主线程等待两个子线程都执行完成后再执行。如果子线程在执行时已经调用了 countDown() 方法，则可以使用 tryAcquireShared(int arg) 方法来判断是否可以继续执行。

执行结果如下：

子线程2正在执行...
主线程正在执行...
子线程1正在执行...
主线程执行完成！

总结

使用 CountDownLatch 时需要避免出现死锁或长时间占用 CPU 等问题，要保证主线程调用 countDown() 方法，避免超过计数器数量调用 countDown() 方法。如果需要在超时之后继续执行程序，可以使用 Semaphore 等同步工具类来实现。