SynchronizedMap 和 ConcurrentHashMap 的区别

SynchronizedMap 和 ConcurrentHashMap 的区别

1. SynchronizedMap

• 定义：通过 Collections.synchronizedMap() 包装普通 HashMap，实现线程安全。
• 锁机制：使用 对象级锁（整个 Map 加锁）。
• 性能：高并发下性能差（锁竞争激烈）。
• 迭代器：迭代时需手动加锁，否则会抛出 ConcurrentModificationException。
• 适用场景：低并发或少量写操作的场景。

2. ConcurrentHashMap

• 定义：专为高并发设计的线程安全 Map（java.util.concurrent 包）。
• 锁机制：Java 7 使用 分段锁，Java 8+ 使用 CAS + synchronized（桶级锁）。
• 性能：高并发下性能优异（锁粒度更细）。
• 迭代器：弱一致性（迭代期间不阻塞，可能反映部分更新）。
• 适用场景：高并发读写场景（如缓存、计数器）。

---

核心区别对比

特性	SynchronizedMap	ConcurrentHashMap
锁粒度	对象级锁（整个 Map）	桶级锁（Java 8+）/分段锁（Java 7）
性能	高并发下性能差	高并发下性能优异
迭代安全性	需手动加锁	弱一致性（无需加锁）
Null 支持	允许 Key/Value 为 null	不允许 Key/Value 为 null
设计目的	简单加锁封装	专为高并发优化

---

典型应用场景

1. SynchronizedMap

   • 低频修改的配置存储
   • 低并发任务共享数据

   Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
   // 写操作（自动加锁）
   map.put("key", "value");
   // 迭代需手动加锁
   synchronized(map) {
       for (String key : map.keySet()) {
           System.out.println(key);
       }
   }
   

2. ConcurrentHashMap

   • 高并发缓存（如 Guava Cache 底层）
   • 实时计数器（如 compute() 原子更新）

   ConcurrentHashMap<String, Integer> counter = new ConcurrentHashMap<>();
   // 原子递增（分段锁优化）
   counter.compute("word", (k, v) -> v == null ? 1 : v + 1);
   // 读操作（无锁优化）
   int count = counter.get("word");
   

---

代码示例

示例 1：SynchronizedMap 基本用法

import java.util.*;

public class SyncMapExample {
    public static void main(String[] args) {
        Map<String, String> syncMap = Collections.synchronizedMap(new HashMap<>());
        
        // 写操作（隐式加锁）
        syncMap.put("name", "Alice");
        syncMap.put("role", "Admin");
        
        // 必须手动加锁迭代！
        synchronized(syncMap) {
            for (Map.Entry<String, String> entry : syncMap.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
        }
    }
}

示例 2：ConcurrentHashMap 高并发计数器

import java.util.concurrent.*;

public class ConcurrentHashMapExample {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Integer> votes = new ConcurrentHashMap<>();
        
        // 模拟 100 个线程并发投票
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                // 原子更新（避免竞争）
                votes.compute("candidateA", (k, v) -> v == null ? 1 : v + 1);
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS);
        
        System.out.println("Total votes: " + votes.get("candidateA")); // 输出 100
    }
}

---

选型建议

• 优先选择 ConcurrentHashMap：适用于绝大多数并发场景（性能优势明显）。
• 谨慎使用 SynchronizedMap：仅在确保低并发或需兼容旧代码时使用。
• 避免嵌套锁：SynchronizedMap 在复合操作（如 putIfAbsent()）中仍需显式加锁，而 ConcurrentHashMap 提供原子方法（如 putIfAbsent()）。

关键结论：在 Java 5+ 环境下，ConcurrentHashMap 是线程安全 Map 的 首选方案。