ConcurrentHashMap源码分析

ConcurrentHashMap源码分析

提前须知

1.本篇针对jdk1.8,jdk1.8中ConcurrentHashMap放弃segment 改用 synchronized(f){} 
2. 在 putVal 方法中，如果发现线程当前 hash 冲突了，也就是当前 hash 值对应的槽位有值了，且如果这个值是 	    -1 （MOVED），说明 Map 正在扩容。那么就帮助 Map 进行扩容。以加快速度。
   对应代码 : else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); //MOVED = -1 即为移动准备的常量 
   static final int MOVED     = -1; // hash for forwarding nodes
   static final int TREEBIN   = -2; // hash for roots of trees
   static final int RESERVED  = -3; // hash for transient reservations
   static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash

put()方法

//HashMap一样,直接调用putval方法,唯一不同的是,此处没有进行hash运算,而是进入到putVal方法以后才有hash运算
public V put(K key, V value) {
    return putVal(key, value, false);
}

putVal()方法

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException(); //key 和 value不能为null
    int hash = spread(key.hashCode());  //hash值计算
    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();//ConcurrentHashMap初始化
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { //该hash槽没有node存在
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // 当第一次将node添加到对应的hash槽时,不加锁
        }
        else if ((fh = f.hash) == MOVED) //node.hash = -1 , 此时map正在扩容
            tab = helpTransfer(tab, f);//帮助扩容的方法
        else { // 以下为链表和红黑树存值
            V oldVal = null;
            synchronized (f) { //同步代码块,以节点为锁 ,线程安全的体现
                if (tabAt(tab, i) == f) {//获得在i位置上的node节点 , 利用的				                                                    //Unsafe.getObjectVolatile地址比较
                    if (fh >= 0) { //代表这是链表节点 , 而不是红黑树节点
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {//遍历所有的node
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {//key相同,值覆盖
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            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)
                    treeifyBin(tab, i);//扩容具体实现
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

initTable方法 ConcurrentHashMap初始化 (只是初始化,没有扩容)

 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(); // 失去了初始化;只是自旋
         else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { //U在下方进行简单解释
             try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY; //sc > 0,则取该值为			ConcurrentHashMap容量值,否则为默认值 16
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; //创建节点数组
                    table = tab = nt;  //table和tab赋值
                    sc = n - (n >>> 2);//修改sc的值
                }
             } finally {
                 sizeCtl = sc;
             }
             break;
         }
     }
     return tab;
 }

helpTransfer(tab,node)方法 (借鉴https://www.jianshu.com/p/39b747c99d32)

final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) { //帮助扩容
    Node<K,V>[] nextTab; int sc;
    // table 不是空 且 node 节点是转移类型 且 node 节点的 nextTable（新 table） 不是空
    if (tab != null && (f instanceof ForwardingNode) &&
        (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
        // 根据 length 得到一个标识符号
        int rs = resizeStamp(tab.length);
        // 如果 nextTab 没有被并发修改 且 tab 也没有被并发修改 且 sizeCtl  < 0 （说明还在扩容）
        while (nextTab == nextTable && table == tab &&
               (sc = sizeCtl) < 0) {
            // 如果 sizeCtl 无符号右移 16 不等于 rs （ sc前 16 位如果不等于标识符，则标识符变化了）
            // 或者 sizeCtl == rs + 1 （扩容结束了，不再有线程进行扩容）（默认第一个线程设置 sc ==rs 左移 16 位 + 2，当第一个线程结束扩容了，就会将 sc 减一。这个时候，sc 就等于 rs + 1）
            // 或者 sizeCtl == rs + 65535  （如果达到最大帮助线程的数量，即 65535）
            // 或者转移下标正在调整 （扩容结束）
            if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                sc == rs + MAX_RESIZERS || transferIndex <= 0)
                break;   // 结束循环，返回 table
            // 如果以上都不是, 将 sizeCtl + 1, （表示增加了一个线程帮助其扩容）
            if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                // 进行转移
                transfer(tab, nextTab);//扩容具体实现
                break;// 结束循环
            }
        }
        return nextTab;
    }
    return table;
}

sizeCtl // -1 :代表table正在初始化,其他线程应该交出CPU时间片
       //-N: 表示正有N-1个线程执行扩容操作（高 16 位是 length 生成的标识符，低 16 位是扩容的线程数）
	  //大于 0: 如果table已经初始化,代表table容量;如果还未初始化,代表需要初始化的大小
链接：https://www.jianshu.com/p/39b747c99d32

U (sun.misc.Unsafe)解释 ,很饶,也不是很懂

在initTable 中出现的U.compareAndSwapInt(this, SIZECTL, sc, -1)其中U表示sun.misc.Unsafe
	这个类的提供了一些绕开JVM的更底层功能，基于它的实现可以提高效率。但是，它是一把双刃剑：正如它的名字所预示的那样，它是Unsafe的，它所分配的内存需要手动free（不被GC回收）。Unsafe类，提供了JNI某些功能的简单替代：确保高效性的同时，使事情变得更简单。
	他的compareAndSwapInt方法解释如下:
	第一个参数为需要改变的对象，第二个为偏移量，第三个参数为期待的值，第四个为更新后的值。整个方法的作用即为若调用该方法时，第二个的值与第三个值相等，那么则将第二个值修改为第四个值，并返回一个true，如果调用该方法时，第二个的值与第三个值不相等，那么不做任何操作，并返回一个false。

与HashMap的差异(见则取,不全)

1.hash值 ConcurrentHashMap使用spread方法,HashMap使用hash()方法 
	解 : spread()在hash()的基础上 & HASH_BITS 即 2^31-1
	static final int spread(int h) {
        return (h ^ (h >>> 16)) & HASH_BITS;
    }
  	
	static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
2.ConcurrentHashMap中 key 和 value都不能为null 否则会抛空指针异常
	 if (key == null || value == null) throw new NullPointerException(); 
3.HashMap put执行第13次进行扩容 , ConcurrentHashMap put执行第12次扩容

存在疑问

1.fh >= 0 为什么可以看出是链表节点 ,而不是树节点 .