解决hashmap线程不安全问题的主要方式有三种：使用collections.synchronizedmap、concurrenthashmap或readwritelock结合hashmap；2. collections.synchronizedmap通过synchronized同步所有方法，实现简单但性能低，适合低并发场景；3. concurrenthashmap采用cas+synchronized（jdk 1.8后），支持高并发，是推荐方案；4. readwritelock适用于读多写少场景，读时不互斥，提升性能但实现复杂；5. hashtable因性能差且不支持null键值，已被concurrenthashmap取代；6. concurrenthashmap底层基于node数组+链表/红黑树，put时先定位桶，空则cas插入，非空则synchronized锁头节点处理冲突；7. 选择应根据并发程度、读写比例、性能和功能需求综合权衡，高并发下优先使用concurrenthashmap。
HashMap本身不是线程安全的，这在多线程环境下会引发数据不一致等问题。Java集合框架提供了多种方式来解决这个问题，并非只有一种“银弹”。
解决方案：
-
使用
Collections.synchronizedMap(new HashMap(...))
: 这是最简单直接的方法。
Collections.synchronizedMap
会返回一个线程安全的
Map
，其内部实现是使用
synchronized
关键字对
HashMap
的所有方法进行同步。这意味着同一时刻只有一个线程可以访问该
Map
。
立即学习“Java免费学习笔记（深入）”；
Map<String, Integer> synchronizedMap = Collections.synchronizedMap(new HashMap<String, Integer>()); Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) { synchronizedMap.put("key" + i, i); } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) { synchronizedMap.get("key" + i); } }); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println("Size: " + synchronizedMap.size()); // 打印结果可能小于1000，因为get操作可能在put之前执行这种方式简单，但性能较低，因为所有操作都需要获取锁，在高并发环境下会成为瓶颈。
-
使用
ConcurrentHashMap
: 这是
java.util.concurrent
包提供的并发安全的
HashMap
实现。
ConcurrentHashMap
采用分段锁（在JDK 1.7及之前）或者CAS+
synchronized
（在JDK 1.8及之后）的方式，允许多个线程同时访问不同的段或桶，从而提高并发性能。
ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>(); Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) { concurrentHashMap.put("key" + i, i); } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) { concurrentHashMap.get("key" + i); } }); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println("Size: " + concurrentHashMap.size()); // 打印结果接近1000ConcurrentHashMap
提供了更高的并发性能，是推荐的线程安全
HashMap
替代方案。
-
使用
ReadWriteLock
结合
HashMap
: 这种方式适用于读多写少的场景。使用
ReadWriteLock
可以允许多个线程同时读取
HashMap
，但只允许一个线程写入。
private final Map<String, Integer> map = new HashMap<>(); private final ReadWriteLock lock = new ReentrantReadWriteLock(); private final Lock readLock = lock.readLock(); private final Lock writeLock = lock.writeLock(); public Integer get(String key) { readLock.lock(); try { return map.get(key); } finally { readLock.unlock(); } } public void put(String key, Integer value) { writeLock.lock(); try { map.put(key, value); } finally { writeLock.unlock(); } }这种方式在读多写少的场景下性能优于
synchronizedMap
，但实现较为复杂。
为什么不直接使用
HashTable
HashTable
？
HashTable
是Java早期提供的线程安全
Map
实现，它使用
synchronized
关键字对所有方法进行同步，与
Collections.synchronizedMap
类似。但
HashTable
的并发性能较差，且不支持
null
键和
null
值，因此在新的代码中通常不推荐使用。
ConcurrentHashMap
在功能和性能上都优于
HashTable
。
ConcurrentHashMap
ConcurrentHashMap
的底层实现原理是什么？
在JDK 1.8中，
ConcurrentHashMap
的底层实现基于
Node
数组 + 链表/红黑树 + CAS +
synchronized
。
- Node数组: 存储键值对，类似于
HashMap
的
table
数组。
- 链表/红黑树: 当
Node
数组的某个位置存在哈希冲突时，会形成链表。当链表长度超过一定阈值（默认为8），且数组长度大于等于64时，链表会转换为红黑树，以提高查找效率。
- CAS: 用于在并发环境下更新
Node
数组中的元素，避免使用锁。
-
: 用于在发生哈希冲突时，对链表或红黑树的头节点进行同步，保证并发安全。
synchronized
ConcurrentHashMap
的
put
操作流程大致如下：
- 计算key的hash值，定位到
Node
数组中的位置。
- 如果该位置为空，则使用CAS尝试将新的
Node
放入该位置。
- 如果该位置不为空，则使用
synchronized
锁住该位置的头节点。
- 遍历链表或红黑树，查找是否存在相同的key。
- 如果存在相同的key，则更新value。
- 如果不存在相同的key，则将新的
Node
插入到链表或红黑树中。
如何选择合适的线程安全
Map
Map
实现？
选择合适的线程安全
Map
实现需要根据具体的应用场景进行权衡。
- 简单场景，并发不高: 可以使用
Collections.synchronizedMap
。
- 高并发场景: 推荐使用
ConcurrentHashMap
。
- 读多写少场景: 可以考虑使用
ReadWriteLock
结合
HashMap
。
此外，还需要考虑以下因素：
- 性能:
ConcurrentHashMap
的并发性能通常优于
Collections.synchronizedMap
和
HashTable
。
- 内存占用:
ConcurrentHashMap
的内存占用可能略高于
HashMap
，因为需要维护额外的并发控制信息。
- 功能:
ConcurrentHashMap
支持更多的并发操作，例如
computeIfAbsent
、
merge
等。
选择合适的线程安全
Map
实现，可以有效地提高程序的并发性能和可靠性。
评论（已关闭）
评论已关闭