简单分析HashMap及其线程安全的Map类

简单分析HashMap及其线程安全的Map类

三种集合的继承实现类图

HashMap

一、简述

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。

二、日常用法

Map<String,Object> map = new HashMap<>();
map.get("");
map.put("",null);
map.clear();
map.isEmpty();
...

Hashtable

一、简述

类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

二、日常用法

Map<String,Object> map = new Hashtable<>();
map.get("");
map.put("",null);
map.clear();
map.isEmpty();
...

ConcurrentHashMap

一、简述

ConcurrentHashMap继承AbstractMap，实现了ConcurrentMap接口。同时ConcurrentMap接口继承Map接口。
简单来说，ConcurrentHashMap属于解决并发情况下的类。拥有HashTable和HashMap的优势。

二、日常使用

Map<String,Object> map = new ConcurrentHashMap<>();
map.get("");
map.put("",null);
map.clear();
map.isEmpty();
...

对比

咋一看HashMap、Hashtable、ConcurrentHashMap用法几乎一致，毕竟都是实现了Map接口，日常使用的也就是Map接口的方法。
重点就是它们各自对实现Map接口具有差异。

举例

下面我们以Map的put方法简单叙述一下它们的线程安全性

HashMap

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

......

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);
else {

......

Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
    return new Node<>(hash, key, value, next);
}

......

Node(int hash, K key, V value, Node<K,V> next) {
    this.hash = hash;
    this.key = key;
    this.value = value;
    this.next = next;
}

当HashMap运行put时，会走

tab[i] = newNode(hash, key, value, null);

为map创建一个新的node节点。节点的hash值是根据key的值计算出来的。Node为HashMap的一个内部类——内部实体对象。一个put的操作背后是有多个线程一起进行操作的。底层有一个Cache，jvm是先把具体的key和value放在缓存的entry中，entry是一个单链。node就和这个单链上的结点一一对应起来。这么看下来，难怪说是性能好，线程不安全，光这么一个put操作，没有看到任何线程安全操作的步骤啊。多线程同时操作这个put方法，在entry这个单链中，谁能保证下一个结点存储的是一个正确的数据。

Hashtable

public synchronized V put(K key, V value) {
    // Make sure the value is not null
    if (value == null) {
        throw new NullPointerException();
    }

    // Makes sure the key is not already in the hashtable.
    Entry<?,?> tab[] = table;
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    Entry<K,V> entry = (Entry<K,V>)tab[index];
    for(; entry != null ; entry = entry.next) {
        if ((entry.hash == hash) && entry.key.equals(key)) {
            V old = entry.value;
            entry.value = value;
            return old;
        }
    }

    addEntry(hash, key, value, index);
    return null;
}

此时Hashtable源码一贴，立马清晰可见，put方法上加了一个synchronized，这不就是一个同步代码块么。具体代码不用分析，大家也就知道了，哦哦~~这个put方法被synchronized修饰了，是线程安全的，多线程同时运行它，方法是一个一个一次运行的，不会出现任何问题。但是这样也带来了一个弊端，性能效率太慢了。。。

ConcurrentHashMap

for (Node<K,V>[] tab = table;;) {

......

transient volatile Node<K,V>[] table;

由此可见，有一个volatile修饰的成员变量table，put操作时，都要去循环迭代这个table。至少我在这块能看到确认它的线程安全性。

代码验证

public class MapTest {

    private static HashMap<String, Integer> map1 = new HashMap<>();
    private static Hashtable<String, Integer> map2 = new Hashtable<>();
    private static ConcurrentHashMap<String, Integer> map3 = new ConcurrentHashMap<>();

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                final int j = i;
                map1.put(String.valueOf(j), j);
            }
        }).start();
        new Thread(() -> {
            for (int a = 5000; a < 10000; a++) {
                final int j = a;
                map1.put(String.valueOf(j), j);
            }
        }).start();
        Thread.sleep(10000);
        System.out.println("HashMap:" + map1.size());
    }
}

如何可以看到HashMap的运行结果永远是不会正确的，就是因为它在put时，node所对应的entry中的hash被冲撞掉了。其他两种Map都是安全的，结果都是正确的。不过现如今已经不推荐使用Hashtable了，如果要使用安全的Map，就用ConcurrentHashMap。