使用 ConcurrentHashMap 进行外部同步的正确姿势

本文探讨了在 Java 中对 ConcurrentHashMap 进行外部同步的必要性与潜在问题。ConcurrentHashMap 本身已具备高效的并发控制机制，直接对其进行外部同步通常是不必要的，甚至会降低其并发性能。文章将介绍 ConcurrentHashMap 的设计原理，并提供更合适的原子更新方法，帮助开发者充分利用其并发特性，避免常见的同步陷阱。

ConcurrentHashMap 是 Java 并发包 java.util.concurrent 中提供的一个线程安全的哈希表实现。它的设计目标是提供比 Hashtable 和使用 Collections.synchronizedMap() 包装的 HashMap 更高的并发性能。ConcurrentHashMap 通过分段锁（在 Java 8 之后采用 CAS 和 synchronized 结合的方式）来实现高效的并发访问。

ConcurrentHashMap 的并发机制

ConcurrentHashMap 的核心思想是将整个哈希表分割成多个独立的段（Segment，在 Java 8 之前），每个段都有自己的锁。当多个线程访问不同的段时，它们可以并发执行，而不需要等待全局锁。这种分段锁机制显著提高了并发性能。在 Java 8 之后，ConcurrentHashMap 摒弃了 Segment 的概念，采用了 CAS（Compare and Swap）和 synchronized 结合的方式来实现更细粒度的并发控制，进一步提升了性能。

避免外部同步

通常情况下，不应该对 ConcurrentHashMap 对象本身进行外部同步（例如使用 synchronized(map)）。原因如下：

1. 破坏并发性：ConcurrentHashMap 的设计已经考虑了并发访问的需求，并提供了内置的并发控制机制。如果使用外部同步，相当于放弃了 ConcurrentHashMap 的并发优势，将其退化成一个串行执行的结构，降低了性能。
2. 可能引发死锁：如果其他线程也在使用 ConcurrentHashMap 提供的并发方法（如 computeIfAbsent），并且这些方法内部也使用了锁，那么外部同步可能会与内部锁产生冲突，导致死锁。
3. Sonar 告警：像 SonarLint 这样的静态代码分析工具通常会检测到对 java.util.concurrent 包中的实例进行同步的操作，并发出警告，因为这通常是一种错误的做法。

正确的原子更新方式

ConcurrentHashMap 提供了多种原子更新方法，可以安全地修改 Map 中的数据，而无需外部同步。以下是一些常用的方法：

刺鸟创客

一款专业高效稳定的AI内容创作平台

下载

• compute(K key, BiFunction super K, ? super V, ? extends V> remappingFunction): 根据指定的键和函数计算新的值，并更新 Map 中的值。如果键不存在，则将计算结果添加到 Map 中。
• computeIfAbsent(K key, Function super K, ? extends V> mappingFunction): 如果指定的键不存在，则使用指定的函数计算新的值，并将其添加到 Map 中。
• computeIfPresent(K key, BiFunction super K, ? super V, ? extends V> remappingFunction): 如果指定的键存在，则根据指定的键和函数计算新的值，并更新 Map 中的值。
• merge(K key, V value, BiFunction super V, ? super V, ? extends V> remappingFunction): 如果指定的键不存在，则将指定的值添加到 Map 中。如果键存在，则使用指定的函数合并现有的值和指定的值，并更新 Map 中的值。
• putIfAbsent(K key, V value): 如果指定的键不存在，则将指定的值添加到 Map 中。

示例代码：

import java.util.concurrent.ConcurrentHashMap;

public class MyClass {
    ConcurrentHashMap map = new ConcurrentHashMap<>();

    public V get(K key) {
        return map.computeIfAbsent(key, this::calculateNewElement);
    }

    protected V calculateNewElement(K key) {
        // calculation of the new element (assignating it to result)
        // with iterations over the whole map
        // and possibly with other modifications over the same map
        // The operations must be atomic
        V result = map.compute(key, (k, v) -> {
            // Perform calculations and modifications here
            // This block is executed atomically for this key
            V newValue = calculateValue(k); // Example calculation
            // Other modifications on the map within this block are also atomic
            return newValue;
        });
        return result;
    }

    private V calculateValue(K key) {
        // Placeholder for your calculation logic
        // Example: Iterate over the map and calculate a new value based on other entries
        synchronized(map){
            // calculation of the new element (assignating it to result)
            // with iterations over the whole map
            // and possibly with other modifications over the same map
            return (V)("Value for " + key);
        }
    }
}

注意事项：

• 在 compute 等原子更新方法的回调函数中，避免执行耗时操作，以免阻塞其他线程对 Map 的访问。如果计算过程复杂，可以考虑将其分解成多个步骤，或者使用线程池来执行计算任务。
• 尽量避免在回调函数中修改 Map 中其他键的值，因为这可能会导致死锁或数据不一致。如果必须修改其他键的值，请谨慎处理，并确保操作的原子性。
• 理解 ConcurrentHashMap 的内部机制对于编写高效的并发代码至关重要。

总结

ConcurrentHashMap 是一个强大的并发工具类，提供了高效的并发访问和原子更新能力。通过正确使用 ConcurrentHashMap 提供的原子更新方法，可以避免外部同步带来的性能问题和潜在的死锁风险。在设计并发程序时，应充分理解 ConcurrentHashMap 的设计原理，并根据实际需求选择合适的并发策略。避免直接对 ConcurrentHashMap 实例进行外部同步，充分利用其内置的并发机制，才能发挥其最大的优势。