Java8并发编程——ConcurrentHashMap详细解读

1 概览

ConcurrentHashMap是一种多线程安全的集合类，主要用到的技术是数组+链表+红黑树+CAS+synchronized，它是在HashMap的基础上，添加了一些操作来保证多程序情况下的安全。

多线程安全：多个线程同时运行（并发），最终的结果，和多个线程串行的结果相同。

2 CHM基本结构

CHM基本结构是数组+链表，它的底层是数组，数组中的每一个元素是一个链表，数组的定义如下：

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

其中Node<K, V>是一个内部类，它的定义如下：

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

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

这个类的第四个成员变量是类本身的一个实例，这就构成了链表。

hash是key的hash值，key是索引，用它来找到value，value就是我们存储的具体的值。

3 put方法

我们从put方法入手，去了解CHM中的实现细节

put方法在1005行左右，如下：

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

具体实现的是putVal方法：

    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        //chm不支持key或者value为null，但是Hashtable支持
        if (key == null || value == null) throw new NullPointerException();
        //计算key的hash值
        int hash = spread(key.hashCode());
        //数组的长度，又叫桶的长度，数组的每一个位置看成一个桶
        int binCount = 0;
        //开始遍历整个数组，table是成员变量
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            //如果数组为空
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();//初始化数组（这是一种懒加载的机制）
            //如果要插入的值所在的桶为空，通过cas插入
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            //如果正在resize，帮助resize
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else { //桶里面已经有元素了，插入到链表的尾部
                V oldVal = null;
                synchronized (f) { //使用synchronized锁住链表
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) { //hash值必须大于0，小于0的有特殊意义
                            binCount = 1; //记录值最终插在了链表的第几个节点，即链表长度
                            for (Node<K,V> e = f;; ++binCount) { //从链表头开始遍历
                                K ek;
                                //如果key已经存在，执行覆盖
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                //如果key之前没有，加到链表尾部
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    //尾插法
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        //如果桶里面已经不是链表了，而是红黑树
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD) //如果链表长度大于64，转红黑树
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

chm的插入操作相对比较复杂，我们通过一个流程图来理解一下：

ConcurrentHashMap中put方法的基本流程

这里面有很多细节，就不一一扣了，大致了解下面这些就够了：

（1）通过cas和synchronized保证线程安全

（2）synchronized锁住的是要插入的桶（链表），而不是整个数组

（3）链表到了一定的阈值会转为红黑树

（4）不同的key，如果计算出的hash值相同，会串在一个链表上，所以chm处理hash冲突的方法是链地址法

（5）相同的key，新的值会覆盖旧的值，所以chm不支持重复的元素，这一点和set不同