CountDownLatch 在 Java 中的应用

CountDownLatch 类是 Java 并发包（java.util.concurrent）中的同步工具类，它允许一个或多个线程等待，直到其他线程中执行的一组操作完成。

1。 CountDownLatch的基本使用

在Java中，CountDownLatch有两个主要方法：await()和countDown()。 wait() 方法会阻塞当前线程，直到 countDown() 方法达到 0 时才会唤醒。 countDown() 方法将计数器减 1。

导入 java.util.concurrent.CountDownLatch;

公开课测试{

    公共静态无效主（字符串[] args）抛出InterruptedException {
        CountDownLatch 锁存器 = new CountDownLatch(2);
        新线程(() -> {
            System.out.println("线程1开始执行");
            闩锁.countDown();
            System.out.println("线程1执行结束");
        }）。开始（）;

        新线程(() -> {
            System.out.println("线程2开始执行");
            闩锁.countDown();
            System.out.println("线程2执行结束");
        }）。开始（）;
    
        闩锁.await();
        System.out.println("所有线程都已执行完毕");
    }
}

2。 CountDownLatch的应用场景

由于CountDownLatch的特性，它通常用于等待其他一些线程完成工作，然后当前线程继续执行。这样可以有效控制任务的并发执行。常见的使用场景包括初始化操作、多线程并发处理等

公共类InitializedUsingLatch {
    私有静态 CountDownLatch 闩锁 = new CountDownLatch(1);

    静态类InitializeThread扩展Thread {
        @覆盖
        公共无效运行（）{
            System.out.println("初始化操作...");
            闩锁.countDown();
        }
    }

    静态类 BusinessThread 扩展 Thread {
        @覆盖
        公共无效运行（）{
            尝试 {
                闩锁.await();
                System.out.println("业务运营...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    公共静态无效主（字符串[] args）抛出InterruptedException {
        新的InitializeThread().start();
        新的 BusinessThread().start();
        新的 BusinessThread().start();
        新的 BusinessThread().start();
    }
}

3。 CountDownLatch 和 CyclicBarrier 的区别

虽然CountDownLatch和CyclicBarrier在某些场景下功能类似，但是它们之间还是有一些本质的区别。 CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。因此，CyclicBarrier可以处理更复杂的业务场景，比如一个复杂的处理过程需要分几个阶段执行。

导入 java.util.concurrent.CyclicBarrier;

公共类 CyclicBarrierDemo {
    公共静态无效主（字符串[] args）{
        最终 CyclicBarrier 屏障 = new CyclicBarrier(3);

        for (int i = 0; i < 3; i++) {
            新线程(() -> {
                System.out.println("线程" + Thread.currentThread().getName() + "等待");
                尝试 {
                    屏障.await();
                } catch (异常 e) {
                    e.printStackTrace();
                }
                System.out.println("线程" + Thread.currentThread().getName() + "继续执行");
            }）。开始（）;
        }
    }
}