ConcurrentHashMap原理解析

概述

ConcurrentHashMap是JDK提供的一个线程安全的集合类，它内部的结构原理和我们常用的HashMap基本是一致，那我们可以先来认识一下HashMap，这样基本上也能大致明白ConcurrentHashMap了。

 

数据结构

HashMap与ConcurrentHashMap都是用来存放一种键值对形式的数据，那它们内部的数据结构是怎么样的呢？

首先来看看HashMap的put方法

public V put(K key, V value) {
    // put方法中首先对key进行hash运算，再调用putVal
    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;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //以下是省略部分代码
        ....
}
        

put方法中调用了putVal()，putVal方法中主要就是往tab中添加元素，而tab是一个数组，即HashMap是通过数组

来存放数据的。数组下标是由(n - 1) & hash计算得出的，这是对数组长度求余的位运算方法，当n为2的倍数时，

hash%n和(n - 1) & hash两者结果相同，但(n - 1) & hash更高效，所以HashMap的容量都是2的倍数。

数组的类型是Node<K,V>[]的，所以HashMap实际保存的也是一组key，value的Node对象，而不单单是value。

Node类是实现Entry接口，所以我们可以通过map.entrySet()方法去遍历HashMap。

 static class Node<K,V> implements Map.Entry<K,V> 

HashMap是通过数组存放数据的，数据对应数组下标的位置由key的hash值决定，但不同key值的hash值是会重复的，

当hash值重复了，数据会怎样的存储？

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);
else {
    Node<K,V> e; K k;
    if (p.hash == hash &&
         ((k = p.key) == key || (key != null && key.equals(k))))
        e = p;
    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) {
                //设置当前位置对象的next元素
                p.next = newNode(hash, key, value, null);
                //当链表数量为8时进行红黑树转换
                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                    treeifyBin(tab, hash);
                    break;
            }
        }        
    }
    ...
}
    

当数组下标元素不为空时，数组元素存放的是一个链表，binCount >= TREEIFY_THRESHOLD - 1(即链表长度为8)时

则会转化为红黑树。

结论

HashMap内部的数据结构是由数组，链表和红黑树组成的，当链表长度为8时会转化为红黑树。

 

HashMap为什么线程不安全
 

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

put方法中这个部分代码表明，当两个线程同时判断该数组下标元素为空时，就会导致数据被覆盖掉的情况。

 

ConcurrentHashMap为什么线程安全

//省略部分代码
...
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
    //通过CAS机制的设置值
    if (casTabAt(tab, i, null,
        new Node<K,V>(hash, key, value, null)))
            break;                   // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED)
    tab = helpTransfer(tab, f);
else {
    V oldVal = null;
    //加synchronized锁
    synchronized (f) {
        //省略部分代码
        ...
    }

static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}

我们可以看到ConcurrentHashMap中判断数组下标元素为空时，调用的是casTabAt，而casTabAt中引用了Unsafe

的compareAndSwapObject方法，Unsafe直接对内存进行操作，判断内存的数据中是否为空，再进行赋值。

当数组下标元素不为空则通过关键字synchronized来保证并非安全。

结论

ConcurrentHashMap线程安全的原理是通过CAS机制和synchronized加锁。