JUC初探之ConcurrentHashMap（未完）

JUC初探之ConcurrentHashMap

摘要

本文从HashMap的演变、内部存储数据结构、put/get/扩容操作以及线程安全几个方面讲解HashMap，并重点讲解ConcurrentHashMap的内部实现原理。

前言

参照JDK的发展历史，最早我们使用HashTable和HashMap结构实现了键值存储数据结构。随着业务发展，系统功能增加，引入了多线程处理来提高系统性能。而这对非线程安全的HashMap提出挑战，顾线程安全的ConcurrentHashMap应运而生。

Map类的集成关系

ConcurrentHashMap的存储结构

/** 存储数据的主要结构 */
transient Node<K,V>[] table;
/** 键值对结构 */
transient Set<Map.Entry<K,V>> entrySet;
/** 计数器: HashMap被修改次数 */
transient int modCount;
/** table初始化以及扩容标记位 */
private transient volatile int sizeCtl;

树化

JDK8中，ConcurrentHashMap同时使用链表和红黑树结构存储元素。

计算元素个数: size()

ConcurrentHashMap针对segment设置锁，那么size()这种全局的统计操作利用CounterCell结构实现了多线程操作数据时的数据可见性问题：

@sun.misc.Contended static final class CounterCell {
        volatile long value;
        CounterCell(long x) { value = x; }
    }

final long sumCount() {
        CounterCell[] as = counterCells; CounterCell a;
        long sum = baseCount;
        if (as != null) {
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

JDK8中无锁化的ConcurrentHashMap

相比与JDK7中put时的加锁操作，JDK8采用volatile变量实现新建Concurrent表的线程安全。
当多个线程同时操作ConcurrentHashMap并执行初始化时，putVal方法发现tab为空并执行initTable方法：

// putVal function
if (tab == null || (n = tab.length) == 0)
  tab = initTable();

initTable()利用sizeCtl成员变量的volatile属性以及线程初始化ConcurrentHashMap时将sizeCtl置为-1的特性实现了初始化的线程安全。

private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

// readObject function
sizeCtl = -1; // force exclusion for table construction

当sizeCtl<0时线程调用Thread.yeild()放弃CPU执行权，但jdk对Thread.yeild的注释让我没想明白为何JUC的作者这么写的目的：

It is rarely appropriate to use this method. It may be useful
     * for debugging or testing purposes, where it may help to reproduce
     * bugs due to race conditions. It may also be useful when designing
     * concurrency control constructs such as the ones in the
     * {@link java.util.concurrent.locks} package.

JDK8采用Node数组作为hash后的数据的”一级索引”，将并发锁的粒度控制到了对Node数组的单个元素，JDK7中则是整个segment，提高了并发性能。通过两张图可以清晰地看到JDK7和JDK8中元素存储方式以及并发锁控制粒度的区别。

扩容

首先我们要明白扩容是对存储元素的数据结构扩容，如JDK7中的HashEntry数组以及JDK8中链表或者tree结构。