5.5. Java并发工具类（如CountDownLatch、CyclicBarrier等）

5.5.1 CountDownLatch

CountDownLatch是一个同步辅助类，它允许一个或多个线程等待，直到其他线程完成一组操作。CountDownLatch有一个计数器，当计数器减为0时，等待的线程将被唤醒。计数器只能减少，不能增加。
示例：使用CountDownLatch等待所有线程完成任务
假设我们有一个任务需要三个子任务完成，我们可以使用CountDownLatch来等待所有子任务完成。

1. import java.util.concurrent.CountDownLatch;
3. public class CountDownLatchExample {
4.     public static void main(String[] args) throws InterruptedException {
5.         CountDownLatch latch = new CountDownLatch(3);
7.         for (int i = 1; i <= 3; i++) {
8.             final int taskNumber = i;
9.             new Thread(() -> {
10.                 System.out.println("Task " + taskNumber + " started");
11.                 try {
12.                     Thread.sleep(1000 * taskNumber);
13.                 } catch (InterruptedException e) {
14.                     e.printStackTrace();
15.                 }
16.                 System.out.println("Task " + taskNumber + " completed");
17.                 latch.countDown();
18.             }).start();
19.         }
21.         System.out.println("Waiting for all tasks to complete...");
22.         latch.await();
23.         System.out.println("All tasks completed");
24.     }
25. }

复制代码

在这个示例中，我们创建了一个CountDownLatch并设置初始计数器为3。每个子任务完成后，调用latch.countDown()减少计数器。主线程调用latch.await()等待所有子任务完成。
5.5.2 CyclicBarrier

CyclicBarrier是一个同步辅助类，它允许一组线程相互等待，直到所有线程都准备好继续执行。当所有线程都到达屏障点时，屏障将打开。CyclicBarrier可以重复使用。
示例：使用CyclicBarrier同步多个线程
假设我们有三个线程需要在某个点同步，我们可以使用CyclicBarrier实现这个目的。

1. import java.util.concurrent.BrokenBarrierException;
2. import java.util.concurrent.CyclicBarrier;
4. public class CyclicBarrierExample {
5.     public static void main(String[] args) {
6.         CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads are ready to proceed"));
8.         for (int i = 1; i <= 3; i++) {
9.             final int taskNumber = i;
10.             new Thread(() -> {
11.                 System.out.println("Task " + taskNumber + " is ready");
12.                 try {
13.                     barrier.await();
14.                 } catch (InterruptedException | BrokenBarrierException e) {
15.                     e.printStackTrace();
16.                 }
17.                 System.out.println("Task " + taskNumber + " is proceeding");
18.             }).start();
19.         }
20.     }
21. }

复制代码

在这个示例中，我们创建了一个CyclicBarrier并设置参与者数量为3。每个线程在准备好继续执行之前调用barrier.await()。当所有线程都准备好时，屏障将打开，所有线程将继续执行。
5.5.3 Semaphore

Semaphore是一个计数信号量，它维护了一个许可集。线程可以请求许可，如果有可用的许可，线程将获得许可并继续执行。否则，线程将阻塞，直到有可用的许可。许可可以由任何线程释放。Semaphore可用于实现资源池、限制并发访问等。
示例：使用Semaphore限制并发访问
假设我们有一个只能同时处理三个请求的服务器，我们可以使用Semaphore来实现并发访问限制。

1. import java.util.concurrent.Semaphore;
3. public class SemaphoreExample {
4.     public static void main(String[] args) {
5.         Semaphore semaphore = new Semaphore(3);
7.         for (int i = 1; i <= 10; i++)            final int clientNumber = i;
8.             new Thread(() -> {
9.                 try {
10.                     System.out.println("Client " + clientNumber + " is trying to connect");
11.                     semaphore.acquire();
12.                     System.out.println("Client " + clientNumber + " is connected");
13.                     Thread.sleep(2000);
14.                     System.out.println("Client " + clientNumber + " is disconnected");
15.                 } catch (InterruptedException e) {
16.                     e.printStackTrace();
17.                 } finally {
18.                     semaphore.release();
19.                 }
20.             }).start();
21.         }
22.     }
23. }

复制代码

在这个示例中，我们创建了一个Semaphore并设置初始许可数量为3。每个客户端线程在连接服务器之前调用semaphore.acquire()请求许可。当许可可用时，线程将获得许可并继续执行。线程完成后，调用semaphore.release()释放许可。
5.5.4 Exchanger

Exchanger是一个同步辅助类，它允许两个线程在一个临界点交换数据。当两个线程都到达交换点时，它们将交换数据。Exchanger可以用于遗传算法、管道设计等。
示例：使用Exchanger交换数据
假设我们有两个线程，一个生成数据，另一个处理数据。我们可以使用Exchanger在这两个线程之间交换数据。

1. import java.util.concurrent.Exchanger;
3. public class ExchangerExample {
4.     public static void main(String[] args) {
5.         Exchanger<String> exchanger = new Exchanger<>();
7.         new Thread(() -> {
8.             try {
9.                 String data = "Data from producer";
10.                 System.out.println("Producer is sending: " + data);
11.                 String receivedData = exchanger.exchange(data);
12.                 System.out.println("Producer received: " + receivedData);
13.             } catch (InterruptedException e) {
14.                 e.printStackTrace();
15.             }
16.         }).start();
18.         new Thread(() -> {
19.             try {
20.                 String data = "Data from consumer";
21.                 System.out.println("Consumer is sending: " + data);
22.                 String receivedData = exchanger.exchange(data);
23.                 System.out.println("Consumer received: " + receivedData);
24.             } catch (InterruptedException e) {
25.                 e.printStackTrace();
26.             }
27.         }).start();
28.     }
29. }

复制代码

在这个示例中，我们创建了一个Exchanger。生产者和消费者线程在交换数据前调用exchanger.exchange(data)。当两个线程都到达交换点时，它们将交换数据。
5.5.5 Phaser

Phaser是一个灵活的同步辅助类，它允许一组线程相互等待，直到所有线程都准备好继续执行。与CyclicBarrier类似，但Phaser更加灵活，可以动态调整参与者数量和支持多个阶段。
示例：使用Phaser同步多个线程
假设我们有三个线程需要在某个点同步，我们可以使用Phaser实现这个目的。

1. import java.util.concurrent.Phaser;
3. public class PhaserExample {
4.     public static void main(String[] args) {
5.         Phaser phaser = new Phaser(3);
7.         for (int i = 1; i <= 3; i++) {
8.             final int taskNumber = i;
9.             new Thread(() -> {
10.                 System.out.println("Task " + taskNumber + " is ready");
11.                 phaser.arriveAndAwaitAdvance();
12.                 System.out.println("Task " + taskNumber + " is proceeding");
13.             }).start();
14.         }
15.     }
16. }

复制代码

在这个示例中，我们创建了一个Phaser并设置参与者数量为3。每个线程在准备好继续执行之前调用phaser.arriveAndAwaitAdvance()。当所有线程都准备好时，屏障将打开，所有线程将继续执行。
这些并发工具类为Java多线程编程提供了强大的支持，帮助我们更轻松地实现各种同步和并发场景。希望这些示例能帮助你理解并掌握这些工具类的用法。
推荐阅读：
https://mp.weixin.qq.com/s/dV2JzXfgjDdCmWRmE0glDA
https://mp.weixin.qq.com/s/an83QZOWXHqll3SGPYTL5g


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！