CyclicBarrier 和 CountDownLatch

CyclicBarrier 和 CountDownLatch 都是 Java 并发编程中的同步工具，用于协调多个线程之间的操作。但它们的实现方式和应用场景有所不同。
CyclicBarrier 是一个可重用的同步屏障，它允许一组线程相互等待，直到所有线程都达到某个屏障点后才继续执行。CyclicBarrier 可以被重复使用，因为一旦所有线程都通过了屏障，它就会被重置为可用状态。CyclicBarrier 的主要应用场景是当一组线程需要相互等待，但它们之间的执行顺序不受限制时。例如，当多个线程需要对某个共享资源进行并发访问时，可以使用 CyclicBarrier 来确保它们之间的互斥性。
CountDownLatch 是一个计数同步器，它允许一个或多个线程等待其他线程完成操作。CountDownLatch 初始化时，计数器的值为指定的数值，每个线程调用 countDown() 方法时，计数器的值会递减。当计数器的值降为 0 时，线程会被阻塞，直到其他线程调用 countDown() 方法唤醒它们。CountDownLatch 的主要应用场景是当一个或多个线程需要等待其他线程完成某些操作时，例如在并发编程中，当一个线程需要等待其他线程完成某些任务后才能继续执行时，可以使用 CountDownLatch。
总的来说，CyclicBarrier 和 CountDownLatch 都是 Java 并发编程中的重要同步工具，但它们的实现方式和应用场景有所不同。在选择使用哪种同步工具时，需要根据具体的应用场景和需求来进行选择。
以下是 CyclicBarrier 和 CountDownLatch 的简单示例代码：
CyclicBarrier 示例代码：

import java.util.concurrent.CyclicBarrier;  
import java.util.concurrent.Semaphore;
public class CyclicBarrierExample {  
   public static void main(String[] args) {  
       int count = 5;  
       CyclicBarrier cyclicBarrier = new CyclicBarrier(count, new Runnable() {  
           @Override  
           public void run() {  
               System.out.println("线程 " + Thread.currentThread().getName() + " 完成任务");  
           }  
       });
       Semaphore semaphore = new Semaphore(count, count);
       for (int i = 0; i < count; i++) {  
           new Thread(new Runnable() {  
               @Override  
               public void run() {  
                   try {  
                       cyclicBarrier.await();  
                       semaphore.acquire();  
                       System.out.println("线程 " + Thread.currentThread().getName() + " 获取到 semaphore");  
                   } catch (InterruptedException e) {  
                       e.printStackTrace();  
                   }  
                   semaphore.release();  
                   System.out.println("线程 " + Thread.currentThread().getName() + " 释放 semaphore");  
               }  
           }).start();  
       }  
   }  
}

CountDownLatch 示例代码：

import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.locks.ReentrantLock;
public class CountDownLatchExample {  
   private static final int COUNT = 5;  
   private static CountDownLatch countDownLatch = new CountDownLatch(COUNT);  
   private static ReentrantLock lock = new ReentrantLock();
   public static void main(String[] args) {  
       for (int i = 0; i < COUNT; i++) {  
           new Thread(new Runnable() {  
               @Override  
               public void run() {  
                   try {  
                       countDownLatch.await();  
                       lock.lock();  
                       System.out.println("线程 " + Thread.currentThread().getName() + " 获取到 countDownLatch");  
                   } catch (InterruptedException e) {  
                       e.printStackTrace();  
                   }  
                   lock.unlock();  
                   System.out.println("线程 " + Thread.currentThread().getName() + " 释放 countDownLatch");  
               }  
           }).start();  
       }  
   }  
}

以上代码分别展示了 CyclicBarrier 和 CountDownLatch 的用法。在 CyclicBarrier 示例中，我们创建了一个 CyclicBarrier 实例，并在其中的 Runnable 中执行任务。在 CountDownLatch 示例中，我们创建了一个 CountDownLatch 实例，并在其中的 Runnable 中执行任务。通过这两个示例，可以更好地理解 CyclicBarrier 和 CountDownLatch 的用法和区别。