谈谈HashMap与HashTable

谈谈HashMap与HashTable

HashMap

我们一直知道HashMap是非线程安全的，HashTable是线程安全的，可这是为什么呢？先聊聊HashMap吧，想要了解它为什么是非线程安全的，我们得从它的原理着手。

jdk7中的HashMap

HashMap底层维护一个数组，数组中的每一项都是Entry

transient Entry<K,V>[] table;

我们向HashMap放置的对象实际上是放置在Entry数组中

而Map中的key、value则以Entry的形式存放在数组中

private static class Entry<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Entry<K,V> next;

而这个Entry应该放在数组的哪一个位置上（这个位置通常称为位桶或者hash桶，即hash值相同的Entry会放在同一位置，用链表相连），是通过key的hashCode来计算的。

当两个key通过hashcode计算是相同的时候，就会发生hash冲突，HashMap解决hash冲突的办法是使用链表。

简而言之就是，jdk1.7的情况：如果该位置没有对象，则将对象直接放到数组中，如果该位置有对象，顺着存在此对象的链找（Map中不允许存在相同的key和value），如果不存在相同的，第一种情况：如果该链表扩容了，则把对象放入到数组中，原先存放在数组中的数据放置该对象的后面。第二种情况：如果该链表没有扩容，则直接放到链表的最后。如果存在相同的，则进行替换。jdk1.8的情况：如果该位置没有对象，则将对象直接放到数组中，如果该位置有对象，顺着存在此对象的链找（Map中不允许存在相同的key和value），如果不存在相同的，则直接放到链表的最后。如果存在相同的，则进行替换。

当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

值得注意的是，HashMap中key和value都允许有null值存在，不过只允许一个null的key，可以有多个null值的value。

jdk8中的HashMap

在JDK1.7的部分就只有链表结构，但是由于链表过长的时候查找元素时间较长，在JDK1.8的时候加入了红黑树，当链表超过一定长度之后，链表就会转换成红黑树，便于查找和插入，在最坏的情况下，链表的时间复杂度是O(n),红黑树是O(logn),这样会提高HashMap的效率。

在jdk8中，当同一个hash值得节点数大于8的时候，将不再以链表的形式存储了，而是会调整成一颗红黑树。

static final int TREEIFY_THRESHOLD = 8;

从JDK1.8开始，HashMap的元素是以Node形式存在，主要结构如下：

 static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

JDK中Entry的名字变成了Node，原因是和红黑树的实现TreeNode相关联。

可以看一下jdk8中的put方法，跟jdk7相比还是做了很大的改变。

    public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //如果当前map中无数据，执行resize方法。并且返回n
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //如果要插入的键值对要存放的这个位置刚好没有元素，那么把他封装成Node对象，放在这个位置上就可以了
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        //如果这个元素的key与要插入的一样，那么就替换一下
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
         //如果当前节点是TreeNode类型的数据，存储的链表已经变为红黑树了，执行putTreeVal方法去存入
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         //还是链表状态
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //判断是否要转成红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //判断阀值，决定是否扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

HashMap的多线程不安全

个人觉得HashMap在并发时可能出现的问题主要是两方面,首先如果多个线程同时使用put方法添加元素，而且假设正好存在两个put的key发生了碰撞(hash值一样)，那么根据HashMap的实现，这两个key会添加到数组的同一个位置，这样最终就会发生其中一个线程的put的数据被覆盖。第二就是如果多个线程同时检测到元素个数超过数组大小*loadFactor，这样就会发生多个线程同时对Node数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给表，也就是说其他线程的都会丢失，并且各自线程put的数据也丢失。

对第二种不安全的情况进行分析：HashMap的死循环

由于插入过程，新插入元素总是插入到头部，源码如下：

void transfer(Entry[] newTable)  {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
    Entry<K,V> e = src[j];
    if (e != null) {
        src[j] = null;
        //这里在做插入的过程中，总是将新插入元素放在链表头
        do {
            Entry<K,V> next = e.next;
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        } while (e != null);
    }
}
}

解析代码：

e=3

Entry<K,V> next = e.next;  保存了3.next也就是7

e.next = newTable[i];  表示3后面跟着的是null，newTable表示重新建立的一张表

newTable[i] = e; 表示在表的下标的那个位置放的是e(也就是3)，也就说下图中的下标为3的地方放了key=3这个对象

e=next；表示e=7了

第二次循环--

Entry<K,V> next = e.next;  保存了7.next也就是5

e.next = newTable[i];   表示7.next=3了，说明3放到7的尾巴上去了

newTable[i] = e;    表示下图中的下标为3的地方放了key=7这个对象

e=next；表示e=5了

又开启了再一次的循环。

为什么会发生死循环呢？

解析：多线程情况下，多个线程同时检测到对数组进行扩容

当线程1正好插入了3（e=3），并且保存了e.next(也就7)

CPU正好切到了线程2，并且完成了扩容，如上图所示。

之后我们对线程1继续进行操作，把7也插进线程1中，可以看到如下所示：

但是由于受到线程2的影响，e=7,e.next=3,我们后面又得插入3了，然后插入3之后，因为3.next=7,所以我们又插入7，这样就形成了死循环。

这个问题在JDK1.8中得到了解决，它用了新的索引插入方式

Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//还是原索引位置
if ((e.hash & oldCap) == 0) {
    if (loTail == null)
        loHead = e;
    else
        loTail.next = e;
    loTail = e;
}
//原索引+ oldCap位置
else {
    if (hiTail == null)
        hiHead = e;
    else
        hiTail.next = e;
    hiTail = e;
    }
} while ((e = next) != null);
if (loTail != null) {
   loTail.next = null;
   newTab[j] = loHead;
 }
if (hiTail != null) {
   hiTail.next = null;
newTab[j + oldCap] = hiHead;
}

由于扩容是在原容量基础上乘以2，那么hash码校验的时候会比原来的多一位，那么只需要比较这个位置是0还是1即可，是1那么就在原索引位置向后位移原容量大小即可，是0就不动。

HashTable

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;
}

在主要的函数上都加了synchronize同步关键字，所有线程竞争同一把锁，所以线程安全。