Java面试知识点（一）（补充）如何让HashMap线程安全

妖狐艹你老母 2021-09-29 09:04 191阅读 0赞

Java HashMap 是非线程安全的。在多线程条件下，容易导致死循环，具体表现为 CPU 使用率 100%。因此多线程环境下保证 HashMap 的线程安全性，主要有如下几种方法：

使用 java.util.Hashtable 类，此类是线程安全的。  
使用 java.util.concurrent.ConcurrentHashMap，此类是线程安全的。  
使用 java.util.Collections.synchronizedMap () 方法包装 HashMap object，得到线程安全的 Map，并在此 Map 上进行操作。

### （一）java.util.Hashtable 类： ###

下面是 Hashtable 的源码：

public synchronized V get(Object key) {   
        Entry tab[] = table;  
        …… // 此处省略，具体的实现请参考 jdk 实现 
        }  
      
    public synchronized V put(K key, V value) {   
        …… // 具体实现省略，请参考 jdk 实现 
        }  
      
      
    public synchronized V remove(Object key) {   
        …… // 具体实现省略，请参考 jdk 实现 
        }  
      
         
        public synchronized void putAll(Map<? extends K, ? extends V> t) {   
            for (Map.Entry<? extends K, ? extends V> e : t.entrySet())  
                put(e.getKey(), e.getValue());  
        }  
      
      
        public synchronized void clear() {   
        …… // 具体实现省略，请参考 jdk 实现 
        }

上面是 Hashtable 提供的几个主要方法，包括 get (), put (), remove () 等。注意到每个方法本身都是 synchronized 的，不会出现两个线程同时对数据进行操作的情况，因此保证了线程安全性，但是也大大的降低了执行效率。因此是不推荐的。

### （二）使用 java.util.Collections.synchronizedMap (Map<K,V>) 方法进行封装。 ###

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {   
        return new SynchronizedMap<K,V>(m);  
        }  
      
      
    private static class SynchronizedMap<K,V>  
        implements Map<K,V>, Serializable {   
        // use serialVersionUID from JDK 1.2.2 for interoperability 
        private static final long serialVersionUID = 1978198479659022715L;  
      
        private final Map<K,V> m;     // Backing Map 
            final Object      mutex;    // Object on which to synchronize 
      
        SynchronizedMap(Map<K,V> m) {   
                if (m==null)  
                    throw new NullPointerException();  
                this.m = m;  
                mutex = this;  
            }  
      
        SynchronizedMap(Map<K,V> m, Object mutex) {   
                this.m = m;  
                this.mutex = mutex;  
            }  
      
        public int size() {   
            synchronized(mutex) { return m.size();}  
            }  
        public boolean isEmpty(){   
            synchronized(mutex) { return m.isEmpty();}  
            }  
        public boolean containsKey(Object key) {   
            synchronized(mutex) { return m.containsKey(key);}  
            }

synchronizedMap使用方式

Map<String,Long> user = Collections.synchronizedMap(new HashMap<>());
        user.put("xsj",1234567l);
        System.out.println(user.get("xsj"));

可以看到 SynchronizedMap 是一个实现了 Map 接口的代理类，该类中对 Map 接口中的方法使用 synchronized 同步关键字来保证对 Map 的操作是线程安全的。

既然已经有了 Hashtable， 为什么还需要 Collections 提供的这种静态方法包装哪？很简单，这种包装是 Java Collection Framework 提供的统一接口，除了用于 HashMap 外，还可以用于其他的 Map。当然 除了对 Map 进行封装，Collections 工具类还提供了对 Collection（比如 Set，List）的线程安全实现封装方法，具体请参考 java.util.Colletions 实现，其原理和 SynchronizedMap 是一致的。

### (三） 使用 java.util.concurrent.ConcurrentHashMap 类。 ###

这是 HashMap 的线程安全版，同 Hashtable 相比，ConcurrentHashMap 不仅保证了访问的线程安全性，而且在效率上有较大的提高。

相对 HashMap 和 Hashtable， ConcurrentHashMap 增加了 Segment 层，每个 Segment 原理上等同于一个 Hashtable， ConcurrentHashMap 为 Segment 的数组。下面是 ConcurrentHashMap 的 put 和 get 方法：

final Segment<K,V> segmentFor(int hash) {   
            return segments[(hash >>> segmentShift) & segmentMask];  
        }  
      
    public V put(K key, V value) {   
            if (value == null)  
                throw new NullPointerException();  
            int hash = hash(key.hashCode());  
            return segmentFor(hash).put(key, hash, value, false);  
        }  
      
    public V get(Object key) {   
            int hash = hash(key.hashCode());  
            return segmentFor(hash).get(key, hash);  
        }

向 ConcurrentHashMap 中插入数据或者读取数据，首先都要讲相应的 Key 映射到对应的 Segment，因此不用锁定整个类， 只要对单个的 Segment 操作进行上锁操作就可以了。理论上如果有 n 个 Segment，那么最多可以同时支持 n 个线程的并发访问，从而大大提高了并发访问的效率。另外 rehash () ——rehash就是扩容之后对数据进行重新存储的过程。操作也是对单个的 Segment 进行的，所以由 Map 中的数据量增加导致的 rehash 的成本也是比较低的。

V put(K key, int hash, V value, boolean onlyIfAbsent) {   
                lock();  
                try {   
                    int c = count;  
                    if (c++ > threshold) // ensure capacity 
                        rehash();  
      
                     …… // 代码省略，具体请查看源码 
      
                } finally {   
                    unlock();  
                }  
            }  
      
    V replace(K key, int hash, V newValue) {   
                lock();  
                try {   
                    HashEntry<K,V> e = getFirst(hash);  
                    
                     …… // 代码省略，具体请查看源码 
                     
                } finally {   
                    unlock();  
                }  
            }

可见对 单个的 Segment 进行的数据更新操作都是 加锁的，从而能够保证线程的安全性。