ConcurrentHashMap的详解

ConcurrentHashMap

1 ConcurrentHashMap导读

HashMap的详解在上篇博客中已经做了详细的解释，最重要的一点是它虽然速度快，但是线程不安全。这都是因为它在get/put的时候没有加锁，HashTable是线程安全的，但是因为用的是synchronized，所以导致get/put的时候锁住的是一整个Hash表，导致性能低下。
基于以上原因，Java实现了ConcurrentHashMap。但在不同版本中实现方式大有不同，JDK1.7版本的ReentrantLock+Segment+HashEntry，到JDK1.8版本中synchronized+CAS+HashEntry+红黑树。
Note：我本机JDK是1.8版本的，所以我就先看1.8版本吧；1.7的暂时先搁置一下。

2 前期知识

2.1 CAS

一般地，锁分为悲观锁和乐观锁：悲观锁认为对于同一个数据的并发操作，一定是为发生修改的；而乐观锁则任务对于同一个数据的并发操作是不会发生修改的，在更新数据时会采用尝试更新不断重试的方式更新数据。
在Java中，悲观锁的实现方式就是各种锁；而乐观锁则是通过CAS实现的。
CAS（Compare And Swap，比较交换）：CAS有三个操作数，内存值V、预期值A、要修改的新值B，当且仅当A和V相等时才会将V修改为B，否则什么都不做。Java中CAS操作通过JNI本地方法实现，在JVM中程序会根据当前处理器的类型来决定是否为cmpxchg指令添加lock前缀。如果程序是在多处理器上运行，就为cmpxchg指令加上lock前缀（Lock Cmpxchg）；反之，如果程序是在单处理器上运行，就省略lock前缀。

2.2 Usafe类

Unsafe类是一个保护类，一般应用程序很少用到，但其在一些框架中经常用到，如JDK、Netty、Spring等框架。Unsafe类提供了一些硬件级别的原子操作，其在JDK1.7和JDK1.8中的ConcurrentHashMap都有用到，但其用法却不同。

compareAndSwapObject(Object o,long l,Object o1,Object o2)：无锁化的修改值的操作
getObjectVolatile(Object obj, long offset)：获取obj对象中offset偏移地址对应的Object型field属性值，支持Volatile读内存语义。

3 ConcurrentHashMap代码详解

JDK1.8的ConcurrentHashMap数据结构比JDK1.7之前的要简单的多，其使用的是HashMap一样的数据结构：数组+链表+红黑树
另外，JDK1.8中的ConcurrentHashMap中还包含一个重要属性sizeCtl，其是一个控制标识符，不同的值代表不同的意思：其为0时，表示hash表还未初始化，而为正数时这个数值表示初始化或下一次扩容的大小，相当于一个阈值；即如果hash表的实际大小>=sizeCtl，则进行扩容，默认情况下其是当前ConcurrentHashMap容量的0.75倍；而如果sizeCtl为-1，表示正在进行初始化操作；而为-N时，则表示有N-1个线程正在进行扩容。

3.1 初始化

需要用到的变量：

• loadFactor：扩容因子
• initialCapacity：初始的大小
• concurrencyLevel：看注释理解是更新线程的数量
• sizeCtl：这个上文提到了

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (initialCapacity < concurrencyLevel)   // Use at least as many bins
        initialCapacity = concurrencyLevel;   // as estimated threads
    long size = (long)(1.0 + (long)initialCapacity / loadFactor);
	//通过移位操作，得出2的次方数
    int cap = (size >= (long)MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : tableSizeFor((int)size);
    this.sizeCtl = cap;
}

3.2 存储

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
		//如果是空列表，初始化列表
            tab = initTable();
        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
        }
		//帮助排序
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
			//锁一个node节点，这样就不会影响其他node的操作
            synchronized (f) {
				//添加节点操作
                ……
            }
            if (binCount != 0) {
				//如果节点数大于TREEIFY_THRESHOLD（8），就要转换成为红黑树了
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

3.3 读取

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
	//获取key值
    int h = spread(key.hashCode());
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        else if (eh < 0)
			//获取value值
            return (p = e.find(h, key)) != null ? p.val : null;
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

遗留

ConcurrentHashMap实现过程自我感觉还是很复杂的，简单的实现已经完全明白了，但是里面还有很多复杂的功能需要继续探索。
JDK1.7的实现只是明白了原理，两次hash，第一次查到Segment，第二次查到HashEntry，然后就可以通过链表去获取了；但是源码还没有看过，这个还需要继续努力。

参考

• ConcurrentHashMap的实现