10.ConcurrentHashMap

1.简介

• concurrentHashMap是一个支持高并发更新与查询的哈希表(基于HashMap)
• 在保证安全的前提下，进行检索不需要锁定。
• 与hashtable不同，该类不依赖于synchronization去保证线程操作的安全。
• 结构
  • JDK1.7 的 ConcurrentHashMap ：
  • 
  • JDK1.8的ConcurrentHashMap （TreeBin: 红黑二叉树节点 Node: 链表节点）  
  •     

2.如何实现安全性

• 在JDK1.8中，放弃了Segment臃肿的设计，取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现，synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。

3.put/putVal方法

public V put(K key, V value) {
    return putVal(key, value, false);
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
    //如果有空值或者空键，直接抛异常
    if (key == null || value == null) throw new NullPointerException();
    //基于key计算hash值，并进行一定的扰动
    int hash = spread(key.hashCode());
    //记录某个桶上元素的个数，如果超过8个，会转成红黑树
    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();
	    //如果hash计算得到的桶位置没有元素，利用cas将元素添加
        //tabAt--获取数组中某一个索引位置的元素 ==table[i]
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            //cas+自旋（和外侧的for构成自旋循环），保证元素添加安全
            //casTabAt(数组,1,2,3)---以CAS的方式，将数组中i位置的数据从2修改为3
            if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))
                break;      //插入成功返回true 跳出 for
        }

--------------------------------------------------------------------------------------------
如何解决hash冲突
        //如果hash计算得到的桶位置元素的hash值为MOVED，证明正在扩容，那么协助扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            //出现了hash冲突 需要将数据挂载链表或红黑树中
            V oldVal = null;
            //对当前桶进行加锁，保证线程安全，执行元素添加操作
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    //当前桶下 不是树(树为-2)  是链表或者是空
                    if (fh >= 0) {
                        //计数器
                        binCount = 1;
                        
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            //key相同 是修改操作 不是添加
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||(ek != null && key.equals(ek)))) {
                                //获取当前key的value值
                                oldVal = e.val;
                                //是否是IfAbsent （false-不是-覆盖数据）  (true-break)
                                if (!onlyIfAbsent)                              
                                    e.val = value;
                                break;
                            }
                            //追加操作
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                     //如果next 指向的是null（当前table[i]为空） 直接插入
                                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) {
                //链表长度大于/等于8，将链表转成红黑树
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                //如果是重复键，直接将旧值返回
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    //添加的是新元素，维护集合长度，并判断是否要进行扩容操作
    addCount(1L, binCount);
    return null;
}

4.spread()方法 --ConcurrentHashMap的散列算法 

用于获取槽位值

int hash = spread(key.hashCode());

static final int spread(int h) {
        //h为key值得hash值,将高16位也参与运算，然后与int最大值进行&运算(效果为将值变为正数，其他位置不变)
        //HASH_BITS为int最大值，最高位为0
        //HashMap中没有处理为正数的步骤，这里负数有其它含义，查看节点类型
        return (h ^ (h >>> 16)) & HASH_BITS;
    }


            

(2)为何要右移16位

                                  00001000 01001000 00010010 00100110  hashcode>>>16

00001000 01001000 00010010 00100110  hashcode

• 若不右移 只有当 tab.length 足够大是 hashcode 的高位才会参与运算
• 右移后 即使 tab.length 不大 也可将高位参与运算

(2)tabAt(tab, i = (n - 1) & hash)  为什么要-1

00000000 00000000 00000000 00010000   tab.length=16

00000000 00000000 00000000 00001111    tab.length-1

• & 都为1 才为 1
• 若不 -1 i 主要由tab.length 决定(10000与的结果0占比高) 冲突率高
• -1 后 i 主要有hash决定(01111 与的结果几乎与hash保持一致)

(3)HASH_BITS

• HASH_BITS=7fff ffff  即 0111 1111 1111 1111 1111 1111 1111 1111
• 保证key 的 hashcode一定为一个正数 
• hashcode为负数时由特殊含义
  • static final int MOVED = -1     当前数据正在迁移
  • static final int TREEBIN = -2   当前节点为树节点
  • static final int RESERVED = -3  当前位置已经被预定

5.initTable()方法，初始化容器

   private final Node<K,V>[] initTable() {
       Node<K,V>[] tab; int sc;
       //判断数组是否初始化
       while ((tab = table) == null || tab.length == 0) {
           //sizeCtl，代表着初始化资源或者扩容资源的锁，必须要获取到该锁才允许进行初始化或者扩容的操作
           if ((sc = sizeCtl) < 0)
               //放弃当前cpu的使用权，让出时间片，线程计入就绪状态参与竞争
               Thread.yield();     
            
           //sizeCtl大于等于0 以CAS的方式将sizeCtl替换成-1 
           else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
               try {
                   //进行一次double check 防止在进入分支前，容器发生了变更（单例模式懒汉的DCL）
                   if ((tab = table) == null || tab.length == 0) {
                       //获取数组初始化的长度 如果sc>0 以sc为长度  如果sc=0 默认长度16
                       int n = (sc > 0) ? sc : DEFAULT_CAPACITY;                       
                       //初始化容器
                       Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                       table = tab = nt;
                       //得到下次扩容的阈值   0.75=n-(1/4)n  
                       sc = n - (n >>> 2);
                   }
               } finally {
                   sizeCtl = sc;
               }
               break;
           }
       }
       return tab;
   }

private transient volatile int sizeCtl;
○ 负数
■ -1：容器进行初始化
■ 其余负数：高16存储resizeStamp()返回的扩容标识符，低16位（1+进行扩容的线程数）
即-2=1个线程正在扩容  -3=2个线程正在扩容
○ 正数
■ 0：未初始化，需要进行初始化
■ 其余正数：当前容器的大小

6. treeifyBin 

红黑树的转化操作

private final void treeifyBin(Node<K,V>[] tab, int index) { 
	Node<K,V> b; int n, sc; 
	if (tab != null) { 
        //tab的长度是不是小于64，如果是，则执行扩容
		if ((n = tab.length) < MIN_TREEIFY_CAPACITY) 
            //尝试扩容 
			tryPresize(n << 1); 
		else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {//否则，将当前链表转化为红黑树结构存储 
			synchronized (b) {// 将链表转换成红黑树 
				if (tabAt(tab, index) == b) { 
					TreeNode<K,V> hd = null, tl = null; 
					for (Node<K,V> e = b; e != null; e = e.next) { 
						TreeNode<K,V> p = new TreeNode<K,V>(e.hash, e.key, e.val,null, null); 
						if ((p.prev = tl) == null) 
							hd = p; 
						else 
							tl.next = p; 
							tl = p; 
					} 
					setTabAt(tab, index, new TreeBin<K,V>(hd)); 
				} 
			} 
		} 
	} 
} 

7.扩容机制

（1）tryPreSize是ConcurrentHashMap扩容方法之一

 private final void tryPresize(int size) {
 //如果大小为MAXIMUM_CAPACITY最大总量的一半，那么直接扩容为MAXIMUM_CAPACITY，否则计算最小幂次方
        int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
            tableSizeFor(size + (size >>> 1) + 1);
        int sc;
          //如果sizeCtl为正数或0   （未初始化（putAll方法） 或 已经初始化了）
        while ((sc = sizeCtl) >= 0) {
            Node<K,V>[] tab = table; int n;
-------------------------------------------------------------------------------------
             //如果table还未进行初始化
            //初始化数组的操作 之前说过
            if (tab == null || (n = tab.length) == 0) {
                n = (sc > c) ? sc : c;
                 //cas修改sizeCtl为-1，表示table正在进行初始化
                if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                    try {
                     //确认其他线程没有对table修改
                        if (table == tab) {
                            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                            table = nt;
                            //0.75*n
                            sc = n - (n >>> 2);
                        }
                    } finally {
                        sizeCtl = sc;
                    }
                }
            }
-------------------------------------------------------------------------------------
             //如果扩容长度<扩容阈值=已经扩容完毕
            //数组长度>=最大长度
            else if (c <= sc || n >= MAXIMUM_CAPACITY)
                break;
------------------------------------------------------------------------------------------------
            else if (tab == table) {
                //得到一个32位的扩容戳 高16位=扩容标识  低16位=扩容线程数
                int rs = resizeStamp(n);
                //SC小于0 已经开始扩容了 其他线程进入时 帮助扩容
                if (sc < 0) {
                    Node<K,V>[] nt;
                    /**1.第一个判断 sc右移RESIZE_STAMP_SHIFT位，也就是比较高ESIZE_STAMP_BITS位生成戳和rs是否相等
                    * 相等则代表是同一个n，是在同一容量下进行的扩容，
                    *  2.第二个和第三个判断 判断当前帮助扩容线程数是否已达到MAX_RESIZERS最大扩容线程数
                    *  3.第四个和第五个判断 为了确保transfer()方法初始化完毕
                    */
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                        break;
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                        transfer(tab, nt);
                }
                //暂时没有线程扩容 先设置SIZECTL标志 开始扩容
                else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null);
            }
        }
    }

（2）transfer()进行扩容

    private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        //【第一步】
        //决定当前线程在需要处理的槽位充足下，分配到的槽位数
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        //新容器为空则创建容器    
        if (nextTab == null) {            // initiating
            try {
                //多出一个赋值操作，尝试处理内存溢出？不明白原理
                @SuppressWarnings("unchecked")
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            //转移索引数设置为当前容器容量
            transferIndex = n;
        }
        //将下个容器的转移搜索引数设置为新容器容量
        int nextn = nextTab.length;
        //创建ForwardingNode容器并放入新容器
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        boolean advance = true;
        boolean finishing = false; // to ensure sweep before committing nextTab
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            //【第二步，划分槽位，帮助推进】
            //选择当前线程进行transfer的槽位，从最后一个槽位向前
            while (advance) {
                int nextIndex, nextBound;
                //向前推进一个槽位，或者已经完成了
                if (--i >= bound || finishing)
                    advance = false;
                //槽位被其它线程选择完了    
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                //尝试获取槽位的操作权
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    //槽位下限                   
                    bound = nextBound;
                    //当前选中进行处理的槽位
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            //被选择完毕，选中槽位大于当前容器容量，选中槽位+当前容器容量大于新容器容量
            //【第三步，设置结束条件，变更地址】
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                //扩容完毕
                if (finishing) {
                    //清除扩容时创建的临时表
                    nextTable = null;
                    //将当前表指向临时表
                    table = nextTab;
                    //设置下次扩容的临界点为 0.75*扩容容量
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                //将扩容标识中的线程标识减一
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    //存在其它线程进行扩容处理，则当前线程处理完自己的槽位后直接退出
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    //不存在其它线程处理，说明自己是唯一处理线程   
                    finishing = advance = true;
                    //将i重置，在看下还有没有transferIndex
                    //如果已经是唯一处理线程并且满足前置条件，为何需要检查下？
                    i = n; // recheck before commit
                }
            }
            //【第四步，处理槽位】
            //如果当前槽中没有成员，用forwarding节点占位
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            //如果当前槽中成员为forwarding节点，代表已经被处理过了    
            else if ((fh = f.hash) == MOVED)
                //处理下一个槽
                advance = true; // already processed
            else {
                //锁住槽位
                synchronized (f) {
                    //double check
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        if (fh >= 0) {
                            //计算当前成员最高位
                            //runBit是0 or 1
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
                                int b = p.hash & n;
                                //查找最后重复的链，获得开始位置p，和重复的高位值runBit
                                if (b != runBit) {
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            //如果从p开始后面高位全是0，那么就不需要移动到新槽中
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            }
                            //如果从p开始后面全是1，那么就需要移动到新槽中
                            else {
                                hn = lastRun;
                                ln = null;
                            }
                            //从链的头部一直遍历到p的位置（因为p以后高位都一样）
                            //为何需要提前找一部分重复？效率更高？这么处理是否有理论依据？
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                //高位为0放到旧槽位中
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                //高位为1放到新槽位中
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            //将ln放到新容器的旧槽位中
                            setTabAt(nextTab, i, ln);
                            //将hn放到新容器的新槽位中
                            setTabAt(nextTab, i + n, hn);
                            //将老容器中的该节点设置为forwarding节点
                            setTabAt(tab, i, fwd);
                            //处理下一个槽位
                            advance = true;
                        }
                        //TreeBin的hash固定为-2，红黑树的调整
                        else if (f instanceof TreeBin) {
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) {
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            //槽位里成员少于等于6，退化为链表
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }