ConcurrentHashMap详解（1.8）

1.7和1.8的区别

• 1.8取消了segment分段锁的设计
• 增加了红黑树的实现

链表的长度大于8 且数组的长度大于64时，此时链表会转为红黑树，当扩容时，假设链表长度小于8 此时红黑树会转换成链表

初始化Tab

-1 表示占位符，如果sizeCtl=-1 则表示已有线程抢到了初始化权限
大于0 数字 sizeCtl=sc = n*0.75 下次扩容的大小
负数（非-1） 代表有几个线程正在扩容 例如 -2 代表有一个线程在扩容

 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];

Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
	//初始化tab值  
    tab = initTable();
//计算数组下标对应的node 是否为空  若为空，则表示当前位置无值
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
	//直接new Node
    if (casTabAt(tab, i, null,
                 new Node<K,V>(hash, key, value, null)))
        break;                   // no lock when adding to empty bin
}

//基于数组下标，计算当前node
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
 //并发保持 可见性  防止多并发时，数据被覆盖
 return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}

//基于cas 做更新
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                Node<K,V> c, Node<K,V> v) {
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}

addCount(1L, binCount);

计数
如何保证并发的size 更新的安全性->原子性：cas？（并发量特别大的时候会不断地cas ,造成性能下降）

private final void addCount(long x, int check) {
  CounterCell[] as; long b, s;
  if ((as = counterCells) != null ||
      !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
      CounterCell a; long v; int m;
      boolean uncontended = true;
      if (as == null || (m = as.length - 1) < 0 ||
          (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
          !(uncontended =
            U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
          fullAddCount(x, uncontended);
          return;
      }
      if (check <= 1)
          return;
      s = sumCount();
  }
  if (check >= 0) {
      Node<K,V>[] tab, nt; int n, sc;
      while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
             (n = tab.length) < MAXIMUM_CAPACITY) {
          int rs = resizeStamp(n);
          if (sc < 0) {
              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);
          }
          else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                       (rs << RESIZE_STAMP_SHIFT) + 2))
              transfer(tab, null);
          s = sumCount();
      }
  }
}

CounterCell 分段CAS 维护一个数据

baseCount用来记录元素个数的成员属性
baseCount 默认是1

//线程安全获取随机数的方式
 h = ThreadLocalRandom.advanceProbe(h);

CELLSBUSY 1 标识当前已有线程扩容

else if (cellsBusy == 0 && counterCells == as &&
                     U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
	 boolean init = false;
	 try {                           // Initialize table
	     if (counterCells == as) {
	         CounterCell[] rs = new CounterCell[2];
	         //通过前面生成的随机数，并进行与运算来确定数组，以此来为多个CounterCell并发提供支持
	         rs[h & 1] = new CounterCell(x);
	         counterCells = rs;
	         init = true;
	     }
	 } finally {
	     cellsBusy = 0;
	 }
	 if (init)
	     break;
	}

//check 一定大于0
if (check >= 0) {
   Node<K,V>[] tab, nt; int n, sc;
   //判断是否需要扩容 sizeCtl 扩容因子
    while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
           (n = tab.length) < MAXIMUM_CAPACITY) {
        int rs = resizeStamp(n);
        //sc < 0 表示当前正在有线程在扩容
        if (sc < 0) {
            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);
        }
        //直接通过CAS 设置SIZECTL
        else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                     (rs << RESIZE_STAMP_SHIFT) + 2))
            transfer(tab, null);
        s = sumCount();
    }
}

ConcurrentHashMap 可以多个线程并行扩容

//n =16 返回一个无符号整数 n的最高位0的个数
static final int resizeStamp(int n) {
    return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}

resizeStamp（16）=32795
0000 0000 0000 0000 1000 0000 0001 1011 左移16位
1000 0000 0001 1011 0000 0000 0000 0000 +2
1000 0000 0001 1011 0000 0000 0000 0010
高16位代表扩容的标记
低16位代表扩容的线程数 -> 有一个线程参与扩容了

需要保证每次扩容的戳是惟一的
可以支持多线程扩容

transfer

1.扩大数组的场长度
2.数据的迁移

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    //n 无符号右移3位，表示n/8  
    //NCPU 标书CPU的核心数 
    // n/8/NCPU  让每个CPU去执行一段数据的扩容，每一个CPU 可以处理16个长度的数组
    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<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;
        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;
                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 = n; // recheck before commit
            }
        }
        else if ((f = tabAt(tab, i)) == null)
            advance = casTabAt(tab, i, null, fwd);
        else if ((fh = f.hash) == MOVED)
            advance = true; // already processed
        else {
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;
                    if (fh >= 0) {
                        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;
                            if (b != runBit) {
                                runBit = b;
                                lastRun = p;
                            }
                        }
                        if (runBit == 0) {
                            ln = lastRun;
                            hn = null;
                        }
                        else {
                            hn = lastRun;
                            ln = null;
                        }
                        for (Node<K,V> p = f; p != lastRun; p = p.next) {
                            int ph = p.hash; K pk = p.key; V pv = p.val;
                            if ((ph & n) == 0)
                                ln = new Node<K,V>(ph, pk, pv, ln);
                            else
                                hn = new Node<K,V>(ph, pk, pv, hn);
                        }
                        //nextTab扩容以后的数组 
                        //低位链路保持不变
                        setTabAt(nextTab, i, ln);
                        //高位链路 需要增加n长度位置
                        setTabAt(nextTab, i + n, hn);
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }
                    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;
                            }
                        }
                        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;
                    }
                }
            }
        }
    }
}

分段扩容 迁移

低位链路保持不变
f = tabAt(tab, i=（n-1）& hash)
假设tab = 16 16的二进制为：10000
i = 16-1 = 15 二进制位：0000 1111
假设 其中 A的key.hash = 9 二进制：0000 1001
0000 1001 & 0000 1111 = 0000 1001 = 9 位置不变
table 长度为：32
0001 1111 & 0000 1111 = 0000 1001 = 9 位置不变
高位链路
B.key.hash = 20 二进制: 0001 0100
table 16 : 0000 1111 & 0001 0100 = 0000 0100
table 32 : 0001 1111 & 0001 0100 = 0001 0100
0000 0100 + 16 = 0001 0100

特点

1.通过数组的方式老实现并发增加元素的个数
2.并发扩容，可以通过多个线程来实现数据的迁移
3.采用高低链的方式来解决多次hash计算的问题
4.sizeCtl的设计， 3中标识状态
5.resizeStamp的设计，高低位的设计来实现为一项以及多个线程的协助扩容记录