17370845950

解决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集合框架提供了多种方式来解决这个问题，并非只有一种“银弹”。

解决方案：

1. 使用

   Collections.synchronizedMap(new HashMap(...))

   : 这是最简单直接的方法。

   Collections.synchronizedMap

   会返回一个线程安全的

   Map

   ，其内部实现是使用

   synchronized

   关键字对

   HashMap

   的所有方法进行同步。这意味着同一时刻只有一个线程可以访问该

   Map

   。

   Map synchronizedMap = Collections.synchronizedMap(new HashMap());
   
   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之前执行

   这种方式简单，但性能较低，因为所有操作都需要获取锁，在高并发环境下会成为瓶颈。

2. 使用

   ConcurrentHashMap

   : 这是

   java.util.concurrent

   包提供的并发安全的

   HashMap

   实现。

   ConcurrentHashMap

   采用分段锁（在JDK 1.7及之前）或者CAS+

   synchronized

   （在JDK 1.8及之后）的方式，允许多个线程同时访问不同的段或桶，从而提高并发性能。

   ConcurrentHashMap 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()); // 打印结果接近1000

   ConcurrentHashMap

   提供了更高的并发性能，是推荐的线程安全

   HashMap

   替代方案。

3. 使用

   ReadWriteLock

   结合

   HashMap

   : 这种方式适用于读多写少的场景。使用

   ReadWriteLock

   可以允许多个线程同时读取

   HashMap

   ，但只允许一个线程写入。

   private final Map 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

是Java早期提供的线程安全

Map

实现，它使用

synchronized

关键字对所有方法进行同步，与

Collections.synchronizedMap

类似。但

HashTable

的并发性能较差，且不支持

null

键和

null

值，因此在新的代码中通常不推荐使用。

ConcurrentHashMap

在功能和性能上都优于

HashTable

。

ConcurrentHashMap

的底层实现原理是什么？

在JDK 1.8中，

ConcurrentHashMap

的底层实现基于

Node

数组 + 链表/红黑树 + CAS +

synchronized

。

• Node数组: 存储键值对，类似于

  HashMap

  的

  table

  数组。
• 链表/红黑树: 当

  Node

  数组的某个位置存在哈希冲突时，会形成链表。当链表长度超过一定阈值（默认为8），且数组长度大于等于64时，链表会转换为红黑树，以提高查找效率。
• CAS: 用于在并发环境下更新

  Node

  数组中的元素，避免使用锁。

• synchronized

  : 用于在发生哈希冲突时，对链表或红黑树的头节点进行同步，保证并发安全。

ConcurrentHashMap

的

put

操作流程大致如下：

1. 计算key的hash值，定位到

   Node

   数组中的位置。
2. 如果该位置为空，则使用CAS尝试将新的

   Node

   放入该位置。
3. 如果该位置不为空，则使用

   synchronized

   锁住该位置的头节点。
4. 遍历链表或红黑树，查找是否存在相同的key。
5. 如果存在相同的key，则更新value。
6. 如果不存在相同的key，则将新的

   Node

   插入到链表或红黑树中。

如何选择合适的线程安全

Map

实现？

选择合适的线程安全

Map

实现需要根据具体的应用场景进行权衡。

• 简单场景，并发不高: 可以使用

  Collections.synchronizedMap

  。
• 高并发场景: 推荐使用

  ConcurrentHashMap

  。
• 读多写少场景: 可以考虑使用

  ReadWriteLock

  结合

  HashMap

  。

此外，还需要考虑以下因素：

• 性能:

  ConcurrentHashMap

  的并发性能通常优于

  Collections.synchronizedMap

  和

  HashTable

  。
• 内存占用:

  ConcurrentHashMap

  的内存占用可能略高于

  HashMap

  ，因为需要维护额外的并发控制信息。
• 功能:

  ConcurrentHashMap

  支持更多的并发操作，例如

  computeIfAbsent

  、

  merge

  等。

选择合适的线程安全

Map

实现，可以有效地提高程序的并发性能和可靠性。