java基础—HashMap实现原理，如何保证HashMap的线程安全？

Java HashMap 是非线程安全的。

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

 
使用 java.util.Hashtable 类，此类是线程安全的。
使用 java.util.concurrent.ConcurrentHashMap，此类是线程安全的。
使用 java.util.Collections.synchronizedMap() 方法包装 HashMap object，得到线程安全的Map，并在此Map上进行操作。
自己在程序的关键方法或者代码段加锁，保证安全性，当然这是严重的不推荐。
 
这里重点分析下上面列举的几种方法实现并行安全性的原理：
 
（一）java.util.Hashtable类：类的主要数据结构如下：
    
Java代码  收藏代码
    /** 
     * The hash table data. 
     */  
    private transient Entry[] table;  
  
private static class Entry<K,V> implements Map.Entry<K,V> {  
    int hash;  
    K key;  
    V value;  
    Entry<K,V> next;  
     
       可见，Hashtable 的实现是一个数组，每个数组元素是一个LinkList结构，因此类的数据实际上保存在一个散列表中。这个实现和 HashMap 的实现是一致的。数据结构如下：


 
      那么Hashtable如何保证线程安全性的哪？下面是 Hashtable的源码：
 
Java代码  收藏代码
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>) 方法进行封装。 方法源代码如下：
 
Java代码  收藏代码
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);}  
        }  
       从实现源代码可以发现，其封装的本质和 Hashtable 的实现是完全一致的，即对原Map本身的方法进行加锁，加锁的对象或者为外部指定共享对象mutex，或者为包装后的线程安全的Map本身。Hashtable 可以理解为 SynchronizedMap mutex=null 时候的特殊情况。因此这种同步方式的执行效率也是很低的。
   
        既然已经有了Hashtable， 为什么还需要Collections 提供的这种静态方法包装哪？很简单，这种包装是Java Collection Framework提供的统一接口，除了用于 HashMap 外，还可以用于其他的Map。当然 除了对Map进行封装，Collections工具类还提供了对 Collection（比如Set，List）的线程安全实现封装方法，具体请参考 java.util.Colletions 实现，其原理和 SynchronizedMap 是一致的。
 
（三） 使用 java.util.concurrent.ConcurrentHashMap 类。这是 HashMap 的线程安全版，同 Hashtable 相比，ConcurrentHashMap 不仅保证了访问的线程安全性，而且在效率上有较大的提高。
 

ConcurrentHashMap的数据结构如下：

 
可以看出，相对 HashMap 和 Hashtable， ConcurrentHashMap 增加了Segment 层，每个Segment 原理上等同于一个 Hashtable， ConcurrentHashMap 为 Segment 的数组。下面是 ConcurrentHashMap 的 put 和 get 方法：
Java代码  收藏代码
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() 操作也是对单个的 Segment 进行的，所以由 Map 中的数据量增加导致的 rehash 的成本也是比较低的。
 
单个 Segment 的进行数据操作的源码如下：
 
Java代码  收藏代码
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 进行的数据更新操作都是 加锁的，从而能够保证线程的安全性。

文章转自：http://liqianglv2005.iteye.com/blog/2025016