HashMap 是不是线程安全的？如果让你来实现一个线程安全的 HashMap 你要怎么设计？如果不用加锁你要怎么设计？

📅 2026-01-13 11:18:25 阅读时间: 14分钟

HashMap 的线程安全性是多线程编程中的一个重要问题，下面我将为你详细解答，并探讨线程安全 HashMap 的设计方案。

🔒 HashMap 的线程安全性分析

HashMap 的非线程安全本质

HashMap 在设计上不是线程安全的。当多个线程同时访问和修改同一个 HashMap 实例时，会导致不可预知的行为。

并发环境下的主要问题：

  • 数据竞争：多个线程同时执行 put/remove 操作可能导致数据丢失或覆盖
  • 死循环：在扩容过程中，多线程可能导致链表形成环，引发 CPU 100% 问题
  • 大小不一致：size() 方法返回的结果可能不准确

特例分析

需要注意的是，当 HashMap 作为方法内的局部变量，且每个线程拥有独立实例时，不存在线程安全问题。

🛠️ 实现线程安全 HashMap 的设计方案

1. 基于锁的线程安全方案

方案一：全局锁机制

java 复制代码 
public class SynchronizedHashMap<K, V> {
    private final HashMap<K, V> map = new HashMap<>();
    private final Object lock = new Object();
    
    public void put(K key, V value) {
        synchronized(lock) {
            map.put(key, value);
        }
    }
    
    public V get(K key) {
        synchronized(lock) {
            return map.get(key);
        }
    }
}

缺点：性能较差，同一时间只能有一个线程访问。

方案二：读写锁优化

java 复制代码 
public class ReadWriteLockHashMap<K, V> {
    private final HashMap<K, V> map = new HashMap<>();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    
    public V get(K key) {
        rwLock.readLock().lock();
        try {
            return map.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }
    
    public void put(K key, V value) {
        rwLock.writeLock().lock();
        try {
            map.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

优势：允许多个读线程并发访问，提高读密集型应用性能。

2. 分段锁设计（JDK7 ConcurrentHashMap 方案）

分段锁将整个哈希表分成多个独立的段（Segment），每个段有自己的锁。

核心设计：

  • 默认 16 个段，可并行访问不同段的数据
  • 段内操作才需要获取锁
  • 显著降低锁竞争概率
java 复制代码 
// 简化的分段锁实现概念
public class SegmentedHashMap<K, V> {
    private final Segment<K, V>[] segments;
    private static final int SEGMENT_COUNT = 16;
    
    static class Segment<K, V> extends ReentrantLock {
        private HashMap<K, V> map = new HashMap<>();
    }
    
    public V get(K key) {
        int segmentIndex = hash(key) & (SEGMENT_COUNT - 1);
        Segment<K, V> segment = segments[segmentIndex];
        segment.lock();
        try {
            return segment.map.get(key);
        } finally {
            segment.unlock();
        }
    }
}

3. JDK8+ ConcurrentHashMap 的进化

JDK8 的 ConcurrentHashMap 放弃了分段锁，采用更精细的锁机制：

核心技术：

  • Node + synchronized + CAS
  • 链表转红黑树（当链表长度 ≥ 8）
  • 多线程协同扩容

锁粒度优化：

从分段锁（锁定多个桶）细化到桶级别锁（只锁定单个链表/树的头节点）。

⚡ 无锁线程安全 HashMap 设计方案

1. CAS（Compare-And-Swap）基础

CAS 是无锁算法的核心，通过硬件保证操作的原子性：

java 复制代码 
public class AtomicExample {
    private AtomicInteger value = new AtomicInteger(0);
    
    public void increment() {
        int oldValue, newValue;
        do {
            oldValue = value.get();
            newValue = oldValue + 1;
        } while (!value.compareAndSet(oldValue, newValue));
    }
}

2. 无锁 HashMap 关键技术

原子引用数组

java 复制代码 
public class LockFreeHashMap<K, V> {
    private final AtomicReference<Node<K, V>[]> table;
    
    public V get(K key) {
        // 无锁读取：依赖 volatile 内存语义
        int index = hash(key) & (table.length() - 1);
        Node<K, V> node = table.get(index);
        while (node != null) {
            if (node.key.equals(key)) return node.value;
            node = node.next;
        }
        return null;
    }
}

无锁插入实现要点：

  1. 原子查找定位：使用 CAS 保证查找-插入的原子性
  2. 无锁链表管理：通过原子引用实现链表操作
  3. 智能排序策略：节点按特定规则排序，简化 rehash

3. 应对 rehash 挑战

rehash 是无锁 HashMap 的最大技术难点，解决方案：

惰性 rehash 策略

  • 不立即移动所有节点
  • 在访问时逐步迁移
  • 使用转发节点标记正在迁移的桶

一致性哈希技巧

通过特殊的哈希位反转排序，使节点在 rehash 时保持相对顺序，避免数据移动。

📊 方案对比与选择指南

下表总结了不同方案的特性对比：

方案 线程安全 性能 实现复杂度 适用场景
全局锁 ✅ 低 简单 低并发，简单应用
读写锁 ✅ 中 中等 读多写少
分段锁 ✅ 中高 复杂 中等并发
ConcurrentHashMap ✅ 高 极复杂 高并发生产环境
无锁实现 ✅ 极高 极其复杂 极限性能需求

💡 实践建议

  1. 优先使用 ConcurrentHashMap
    对于大多数应用场景，JDK 提供的 ConcurrentHashMap 是最佳选择。

  2. 谨慎考虑自定义无锁实现

    • 无锁编程极其复杂，容易出错
    • 需要深入的并发知识和严格的测试
    • 仅在性能瓶颈明确且 ConcurrentHashMap 无法满足时考虑

  3. 原子操作的合理使用

    java 复制代码 
    // 使用内置原子方法，避免手动同步
concurrentMap.compute("key", (k, v) -> v == null ? 1 : v + 1);

💎 总结

HashMap 确实是非线程安全的，在多线程环境下必须使用同步机制。从简单的全局锁到精细的分段锁，再到复杂的无锁实现，各种方案在性能与复杂度之间有不同的权衡。对于绝大多数实际项目，推荐使用 JDK 提供的 ConcurrentHashMap，它经过了充分测试和优化，能够满足高并发场景的需求。

希望这份详细的解答能帮助你更好地理解 HashMap 的线程安全问题和解决方案！如果你有特定场景的需求，我可以提供更具体的设计建议。

返回文章列表