ConcurrentHashMap源码剖析

一、ConcurrentHashMap的存储结构(常识性讲解)
ConcurrentHashMap是一个安全的HashMap,在JDK1.8中ConcurrentHashMap和HashMap的存储结构一样，key-value,存储结构，数组➕链表➕红黑树
JDK1.8会引入红黑树的原因：
当链表的长度过长，则会严重影响HashMap的性能，红黑树搜索时间复杂度是O(logn),而链表则是O(n),因此Jdk1.8对数据结构做了进一步的优化，引入了红黑树，
链表转换成红黑树的条件：
当链表>8 && 数组>64 会转换成红黑树

举例说明HashMap和ConcurrentHashMap

public static void main(String[] args) {
 // 如果是并发的复合操作，那么就凉凉 Long count = map.get("test"); 
 if (count == null) { 
 		map.put("test", 1L); }
  else { map.put("test", count + 1); } 
 // 在ConcurrentMap接口中提供了几个方法 
 // 1. putIfAbsent(key,value)，当map中的key不存在时，就将key-value存储进去，并返回null， 如果存在，什么都不做 
 // 2. boolean replace(K key, V oldValue, V newValue); 替换时，需要保证存在的key-oldValue完全匹配，才会将newValue替换掉之前的oldValue // 如果replace成功替换，返回true，否则返回false
 while (true) {
            Long count = map.get("test");
            if (count == null) {
                // 现在map中没有这个key
                if (map.putIfAbsent("test", 1L) == null) {
                    // A == null
                    break;
                }
            } else {
                // 现在map中有这个key，将value + 1
                // B == 1
                if (map.replace("test", count, count + 1))
                    break;
            }
        }
        // ConcurrentHashMap是为了保证并发操作map时，map的数据不会被破坏，但是当多线程复合操作map时，ConcurrentHashMap是无法保证安全的
    }
}

二、分析ConcurrentHashMap的put源码

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // key和value如果为null，直接甩异常
    if (key == null || value == null) throw new NullPointerException();
    // 计算key的hash值，（通过hash值决定Entry存放到数组的哪个索引位置）
    int hash = spread(key.hashCode());
    // 暂时当做标识，值为0
    int binCount = 0;
    // 是死循环，开始！！声明临时变量为tab，tab赋值了table，table就是当前HashMap的数组！
    for (Node<K,V>[] tab = table;;) {
        // 声明了一堆变量
        Node<K,V> f; int n, i, fh;
        // 如果tab为null，或者tab的长度为0
        if (tab == null || (n = tab.length) == 0)
            // 进来说明数组没有初始化，开始初始化，ConcurrentHashMap要避免并发初始化时造成的问题，这里深入研究一下
            tab = initTable();
        // tabAt(数组，索引位置)，得到这个数组指定索引位置的值，f就是数组的下标位置的值
        // 如果f == null
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 进到这，说明索引位置没有值，基于CAS的方式将当前的key-value存储到这个索引位置
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                // 如果CAS成功，添加数据成功（添加到了数组上），如果走false，继续上述操作，尝试其他内容
                break;                   // no lock when adding to empty bin
        }
        // f是经过上述if得到的索引位置的值，当前key-value的hash是否为MOVED，如果相等，证明当前位置正在扩容
        else if ((fh = f.hash) == MOVED)
            // 如果正在扩容，帮你扩容（构建长度为原来2倍的数组，并且将老数组的值移动到新数组），帮助扩容的操作是迁移数据的操作
            tab = helpTransfer(tab, f);
        else {
            // 第一个判断：数组初始化了么？
            // 第二个判断：数组指定的位置有值么？
            // 第三个判断：现在正在扩容么？
            // 第四个判断：是否需要将数据挂到链表上，或者添加到红黑树中？（出现了Hash冲突（碰撞））
            V oldVal = null;
			// 加个锁，锁的是f（f是什么？）
            synchronized (f) {
                // 判断f是否为当前数组指定下标的位置
                if (tabAt(tab, i) == f) {
   					// 如果fh 大于等于 0（判断hash值是否大于等于0），说明是链表
                    if (fh >= 0) {
						// 将标识修改为1
                        binCount = 1;
						// 开始循环，为了将插入的值挂到链表的最后面
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&    // 当前指向的节点和要插入的节点的hash值是否相等
                                (
									(ek = e.key) == key ||      // 判断指向的节点的key是否等于当前要插入的节点的key
                                    key.equals(ek))) {   // 指向的节点的key是否域当前的key相等
								// 说明当前是修改操作
                                oldVal = e.val;
                                if (!onlyIfAbsent)  // onlyIfAbsent如果为true，就什么事都不做
                                    e.val = value;   // 修改值
                                break;
                            }
                            // 是正常的添加操作
                            Node<K,V> pred = e;
							// 如果节点的next为null，说明到链表的最后一个节点了，添加到链表的末尾
                            if ((e = e.next) == null) {
								// 将当前值添加到链表的最后一个节点的next指向
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
					// 判断当前位置的桶数据是否是树
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
						// 标记修改为2
                        binCount = 2;
						// 调用putTreeVal扔到红黑树
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
							// 进到if说明是覆盖操作
                            oldVal = p.val;
                            if (!onlyIfAbsent)   // 根据判断决定，是否修改数据
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

三、ConcurrentHashMap的spread方法

int hash = spread(key.hashCode());
static final int spread(int h) {
    //  (h ^ (h >>> 16))：HashMap的散列算法     HashMap默认的数组长度是：16
    //  Entry存放的索引位置 = (数组长度 - 1) & hash
    //  & HASH_BITS的运算目的是为了保证等到的hash值，一定是正数，因为最高位符号位100%是0
    //  因为hash值为负数时，有特殊的含义，
    return (h ^ (h >>> 16)) & HASH_BITS;

    static final int MOVED     = -1; // 当前索引位置的数据正在扩容
    static final int TREEBIN   = -2; // 当前索引位置下面不是链表，是红黑树
    static final int RESERVED  = -3; // 当前索引位置被临时占用，compute方法会涉及
}

四、ConcurrentHashMap的initTable方法

/*
sizeCtl = -1：说明当前ConcurrentHashMap正在初始化！！！
sizeCtl = -N：说明当前ConcurrentHashMap正在扩容！！！
sizeCtl = 0：默认初始值，当前ConcurrentHashMap还没有初始化
sizeCtl > 0：如果已经初始化过了，sizeCtl标识扩容的阈值，  如果没有初始化，sizeCtl标识数组的初始化容量
*/
tab = initTable();
private final Node<K,V>[] initTable() {
    // 声明一些变量
    Node<K,V>[] tab; int sc;
    // tab变量是HashMap的数组，  数组长度为null，或者数组的长度为0，说明数组还没有初始化！
    while ((tab = table) == null || tab.length == 0) {
        // 将sizeCtl赋值给sc，如果进到if中，说明正在扩容或者正在初始化
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // 线程让一手~~
        // 以CAS的方式，尝试将sizeCtl从之前oldValue替换为-1，为了标识我当前ConcurrentHashMap正在初始化
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            // 开始扩容
            try {
                // table是不是还是null，或者长度还是0
                if ((tab = table) == null || tab.length == 0) {
				    // 声明n，sc是sizeCtl，默认sizectl为0，但是现在正在初始化，我把sizeCtl改为了-1，但是sc还是0
	                // sc如果为0，不大于0，所以为DEFAULT_CAPACITY，16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    // 创建数组！！！
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    // 将初始化的nt数组赋值给ConcurrentHashMap的table
                    table = tab = nt;
                    // 默认sc = 12，为扩容阈值
                    sc = n - (n >>> 2);
                }
            } finally {
                // 将阈值赋值给sizeCtl，到这初始化完毕
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;