Java并发编程：CountDownLatch、CyclicBarrier详解实例-蒲公英云

Java并发编程：CountDownLatch、CyclicBarrier详解实例

Java并发编程中，CountDownLatch和CyclicBarrier是两个常用的同步辅助类，它们都位于java.util.concurrent包中。下面我将分别解释这两个类，并提供一些实例。

CountDownLatch`CountDownLatch`是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

特点：

CountDownLatch的计数器不能被重置。
-它通常用于某个线程需要等待其他线程完成某些操作的场景。

实例：

```javaimport java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
public static void main(String[] args) throws InterruptedException {
final int threadCount =3;
CountDownLatch latch = new CountDownLatch(threadCount);

for (int i =0; i < threadCount; i++) {
new Thread(new Worker(latch)).start();
}

latch.await(); //等待所有线程完成 System.out.println(“所有任务完成”);
}

static class Worker implements Runnable {
private final CountDownLatch latch;

public Worker(CountDownLatch latch) {
this.latch = latch;
}

@Override public void run() {
try {
System.out.println(Thread.currentThread().getName() + “正在执行任务”);
//模拟任务执行时间Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + “任务完成”);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
latch.countDown(); //任务完成，计数器减1 }
}
}
}
``### CyclicBarrierCyclicBarrier`是一个同步辅助类，它允许一组线程互相等待，直到所有线程都到达一个公共屏障点（barrier point）。

特点：

CyclicBarrier的计数器可以被重置，因此可以重复使用。
-它通常用于固定数量的线程需要相互等待的场景。

实例：

```javaimport java.util.concurrent.CyclicBarrier;
import java.util.concurrent.BrokenBarrierException;

public class CyclicBarrierExample {
public static void main(String[] args) {
final int threadCount =3;
CyclicBarrier barrier = new CyclicBarrier(threadCount, new Runnable() {
@Override public void run() {
System.out.println(“所有线程已到达屏障点，继续执行”);
}
});

for (int i =0; i < threadCount; i++) {
new Thread(new Worker(barrier)).start();
}
}

static class Worker implements Runnable {
private final CyclicBarrier barrier;

public Worker(CyclicBarrier barrier) {
this.barrier = barrier;
}

@Override public void run() {
try {
System.out.println(Thread.currentThread().getName() + “正在执行任务”);
//模拟任务执行时间Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + “到达屏障点，等待其他线程”);
barrier.await(); //等待其他线程到达屏障点 System.out.println(Thread.currentThread().getName() + “继续执行”);
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
}
``在这两个例子中，CountDownLatch用于等待所有线程完成，而CyclicBarrier`用于让所有线程在屏障点等待，直到所有线程都到达屏障点后一起继续执行。这两个类在并发编程中非常有用，可以帮助你更好地控制线程间的同步。