在Java并发编程领域，作为一名高级程序员，我广泛使用了多种并发工具类来构建高效、可维护且可扩展的并发应用程序。这些工具类不仅简化了并发编程的复杂性，还提供了强大的功能来确保线程安全和数据一致性。以下是我经常使用的一些Java并发工具类，以及它们的应用场景和示例代码。

1. ExecutorService

ExecutorService 是 Java 并发框架中用于管理线程池的一个关键类。它提供了灵活的线程池管理功能，包括任务的提交、执行、取消以及结果查询等。使用线程池可以有效减少线程创建和销毁的开销，提高系统性能。

示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(4);

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            int taskId = i;
            executor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " is processing task " + taskId);
                // 模拟任务执行时间
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池（不再接受新任务，但已提交的任务会继续执行）
        executor.shutdown();
    }
}

2. CountDownLatch

CountDownLatch 是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。这在需要等待多个任务并行完成后继续执行后续任务的场景中非常有用。

示例代码：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3); // 等待3个任务完成

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is running");
                // 模拟任务执行
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                latch.countDown(); // 完成任务，计数器减一
            }).start();
        }

        latch.await(); // 等待所有任务完成
        System.out.println("All tasks are completed.");
    }
}

3. CyclicBarrier

CyclicBarrier 是一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点（common barrier point）。在屏障点之前，每个线程都会阻塞，直到最后一个线程到达屏障点，此时屏障会被打破，所有线程继续执行。

示例代码：

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads have reached the barrier."));

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " is ready to wait at the barrier.");
                    barrier.await(); // 等待其他线程
                    System.out.println(Thread.currentThread().getName() + " has crossed the barrier.");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

4. Semaphore

Semaphore 是一个计数信号量，用于控制同时访问某个特定资源或资源池的操作数量，或者同时执行某个指定操作的数量。它通常用于实现资源池或限制并发访问的数量。

示例代码：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final int MAX_PERMITS = 5;
    private final Semaphore semaphore = new Semaphore(MAX_PERMITS);

    public void doSomething() {
        try {
            semaphore.acquire(); // 请求许可
            // 模拟任务执行
            System.out.println(Thread.currentThread().getName() + " is processing.");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release(); // 释放许可
        }
    }

    // 示例用法，略去具体实现
}

总结

以上提到的 ExecutorService、CountDownLatch、CyclicBarrier 和 Semaphore 是Java并发编程中非常有用的工具类。它们各自解决了并发编程中的不同问题，如线程池管理、线程同步、并发控制等。通过合理使用这些工具类，可以大大提高并发程序的性能和可维护性。在码小课网站上，我们深入探讨了这些并发工具类的使用场景和最佳实践，帮助开发者更好地掌握Java并发编程。