项目 更喜欢并发实用程序来等待和通知

Java并发编程：高效利用java.util.concurrent

自Java 5以来，java.util.concurrent包提供了强大的并发工具，替代了复杂的手动等待/通知机制，提升了代码安全性、易用性和效率。本文将探讨该包中的核心组件及其应用。

java.util.concurrent的核心组件

该包主要包含以下几类并发实用程序：

• 执行器框架 (Executor Framework): 用于线程管理，在第80条中有所介绍。
• 并发集合 (Concurrent Collections): 提供了线程安全的List、Queue和Map等标准集合的实现。
• 同步器 (Synchronizers): 用于协调线程间的操作，包括CountDownLatch、Semaphore、CyclicBarrier、Exchanger和Phaser。

并发集合：高效的线程安全

并发集合的特点在于其内部同步机制，确保了高性能的同时避免了竞争条件。 原子操作，例如putIfAbsent，进一步增强了安全性及可用性。 例如，使用ConcurrentHashMap实现线程安全的Map：

Map<String, String> map = new ConcurrentHashMap<>();
String result = map.putIfAbsent("key", "value");
if (result == null) {
    System.out.println("Value inserted.");
} else {
    System.out.println("Key already exists with value: " + result);
}

并发集合显著提升了性能，并替代了传统的Collections.synchronizedMap()等方法。

同步器：精细的线程协调

同步器用于协调多个线程间的执行顺序和资源访问。 常见的同步器包括：

• CountDownLatch：一次性屏障，用于等待多个线程完成任务。
• Semaphore：控制对共享资源的访问权限。
• CyclicBarrier：可重用的屏障，用于同步多个线程在特定点汇合。
• Phaser：更高级的动态线程同步机制。

案例：使用CountDownLatch进行并发计时

以下代码演示如何使用CountDownLatch测量多个线程同时执行的时间：

public static long time(Executor executor, int concurrency, Runnable action) throws InterruptedException {
    CountDownLatch ready = new CountDownLatch(concurrency);
    CountDownLatch start = new CountDownLatch(1);
    CountDownLatch done = new CountDownLatch(concurrency);

    for (int i = 0; i < concurrency; i++) {
        executor.execute(() -> {
            try {
                ready.countDown(); // Signal ready
                start.await();     // Wait for start signal
                action.run();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                done.countDown(); // Signal done
            }
        });
    }

    ready.await();   // Wait for all threads to be ready
    long startTime = System.nanoTime();
    start.countDown(); // Trigger start
    done.await();     // Wait for all threads to finish
    return System.nanoTime() - startTime;
}

代码使用了三个CountDownLatch：ready表示线程准备就绪，start用于发出开始信号，done用于指示所有线程完成。 System.nanoTime()用于精确计时。

等待/通知机制的现代实践

等待/通知机制主要用于维护遗留代码。 其最佳实践包括：

1. 使用循环调用wait()：避免虚假唤醒。

synchronized (lock) {
    while (!condition) {
        lock.wait();
    }
}

2. 在等待前后检查条件。
3. 优先使用notifyAll()而非notify()。

结论

java.util.concurrent包提供了高效且安全的并发工具，应优先于手动等待/通知机制。 选择合适的并发集合和同步器可以显著提升代码的可读性、安全性以及性能。