ConcurrentHashMap源码解析 java8

源码的学习是有趣的，受益颇多的，你一定能够获得惊喜。

前一阶段出去面试的时候被问到ConcurrentHashMap，当时回答的时候只是泛泛而谈，谈了其特点，与jdk 1.7相比的优点等等。但是隐约感觉到面试官不太满意，后来反思了一下，是没有深入到源码层面进行功能实现的解析，导致说出来的话都没有说服力，因此研究一下，用作记录和学习。

ConcurrentHashMap主要方法是put与扩容，先说下put方法。

（背景：面试官直接问我：ConcurrentHashMap是怎么实现线程安全的，是直接在put方法上面加锁吗？）

// put方法是直接调用putVal方法的
final V putVal(K key, V value, boolean onlyIfAbsent) {
// key或者value是null就直接抛出空指针
        if (key == null || value == null) throw new NullPointerException();
        // spread方法根据key的hashCode值算出hash值
        int hash = spread(key.hashCode());
        // 链表的长度
        int binCount = 0;
        // 循环table，和while(true)一样，break的时候才能退出，注意这个时候tab是可能为null或者size==0的
        // 这里其实就是自旋操作，当出现线程竞争时不断自旋
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            // tab为null或者size==0，就初始化tab
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            // 通过hash值对应的数组得到第一个节点；以volatile读的方式读取table数组中的元素，保证每次拿到的都是最新的值
            // 如果当前数组的值为null，就使用cas放入，cas成功返回true，然后break跳出循环，put结束；cas失败则进行下一次循环。
            //这里的tabAt和casTabAt都是Unsafe的nativa方法。这两个方法的源码的作者使用Unsafe直接通过数组内存地址以及索引偏移量去访问和修改数组元素的值，和我们直接使用java代码访问arr[i]的区别是，java中的数组是经过了包装的，通过java代码来访问避免数组越界异常ArrayIndexOutOfBoundsException。
            // 总结：ConcurrentHashMap中针对table数组的Unsafe访问和赋值的意义应该是在于越过jvm对数组操作的包装，进而达到优化性能的目的。
            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
            }
            --------------------------------------------
            /*假如在上面这段代码中存在两个线程，在不加锁的情况下：
            线程A成功执行casTabAt操作后，随后的线程B可以通过tabAt方法立刻看到table[i]的改变。
            原因如下：线程A的casTabAt操作，具有volatile读写相同的内存语义，
            根据volatile的happens-before规则：线程A的casTabAt操作，一定对线程B的tabAt操作可见*/
            --------------------------------------------
            // 如果达到阈值，则转移元素，进行扩容
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            // 下面的方法也就是说，数组头节点有数值，则对头节点加锁
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                    // 如果是链表，遍历链表
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                // 遇到key值==或者equal的key，就替换掉value，结束
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                // 或者遍历直到e.next=null时,结束
                                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;
                            }
                        }
                    }
                }
                // 若链表长度是否大于等于8，将链表转换成红黑树
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

ConcurrentHashMap数组扩容是比较难的地方。未完待续～～～

参考文章1：http://www.sohu.com/a/320372210_120176035
参考文章2：https://javadoop.com/post/hashmap