CyclicBarrier和CountDownLatch的区别

引言

在并发编程中，CyclicBarrier和CountDownLatch是两个常用的同步工具类。它们都可以用于线程之间的等待和协调，但在使用方式和功能上有一些区别。本文将深入探讨CyclicBarrier和CountDownLatch的区别，并给出相应的代码示例。

CyclicBarrier和CountDownLatch简介

CyclicBarrier

CyclicBarrier是Java提供的一种同步辅助类，它可以让一组线程互相等待，直到到达某个公共屏障点。当所有线程都到达屏障点后，这些线程才能继续执行后续的操作。

CountDownLatch

CountDownLatch也是Java提供的一种同步辅助类，它可以让一个或多个线程等待，直到其他线程执行完一组操作后再继续执行。

区别对比

下面是CyclicBarrier和CountDownLatch的区别对比：

1. 使用方式

CyclicBarrier的使用方式相对复杂一些，需要明确指定线程的数量，并在每个线程到达屏障点后执行特定的操作。

CountDownLatch的使用方式相对简单，只需要调用await()方法等待其他线程执行完一组操作即可。

2. 是否可重用

CyclicBarrier可以重用，即在所有线程到达屏障点后，屏障会自动重置，线程可以继续使用。

CountDownLatch不能重用，一旦计数器减到0，就无法再次使用。

3. 等待方式

CyclicBarrier等待线程的方式是通过await()方法进行等待，可以选择等待一定的时间或者等待其他线程到达。

CountDownLatch等待线程的方式是通过await()方法进行等待，直到计数器减到0。

4. 功能

CyclicBarrier主要用于线程之间的等待和协调，在所有线程到达屏障点后可以执行特定的操作。

CountDownLatch主要用于等待其他线程执行完一组操作后再继续执行。

代码示例

下面给出一个简单的CyclicBarrier和CountDownLatch的代码示例：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.CountDownLatch;

public class CyclicBarrierDemo {
    public static void main(String[] args) throws InterruptedException {
        final int threadCount = 5;
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount, () -> {
            System.out.println("所有线程已到达屏障点");
        });

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            new Thread(() -> {
                try {
                    System.out.println("线程" + threadNum + "已到达屏障点");
                    cyclicBarrier.await();
                    System.out.println("线程" + threadNum + "继续执行");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        final int threadCount = 5;
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            new Thread(() -> {
                try {
                    System.out.println("线程" + threadNum + "开始执行");
                    Thread.sleep(1000);
                    System.out.println("线程" + threadNum + "执行完毕");
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        countDownLatch.await();
        System.out.println("所有线程执行完毕");
    }
}