ConcurrentHashMap源码阅读记录--JDK8

------------------------------------2017.11.10更新----------------------------

突然想起扩容的逆序问题，搜了一下没有找到满意的答案，不过找到了下面这篇文章，http://www.jianshu.com/p/f6730d5784ad，

其中分析了扩容时链表拆分的过程，下面试着寻找“一部分逆序一部分原序”的原因，水平有限，欢迎指教！！！

假设数据如下图：

在14槽位插入数据，链表长度已经为8，执行treeifyBin，表长度小于64（MIN_TREEIFY_CAPACITY），执行tryPresize(n << 1);扩容，对14槽位数据标号如下：

链表处理部分代码：

                    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);
                            }
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }

先看第一个for循环，runBit = fh & n;区分出数据在扩容后在table中的位置

                                if (b != runBit) {
                                    runBit = b;
                                    lastRun = p;
                                }

记录最后一次位置变更，循环后 lastRun指向节点6，runBit指向高位hn，把上图拿过来对比发现6后面的数据都是不需要处理了，节点6 就是最后一个需要遍历的节点，即lastRun

分析到这里大神Doug Lea的意图已经可以看出来了，

先看最后效果

ln链：

hn链：

节点6后面的数据保持原序，再看源码第二个for循环，就知道逆序的原因了，

结论就是最后一个变更点之后的数据顺序不变，之前的会逆序，逆序原因在于Node节点的构造方法

Node(int hash, K key, V val, Node<K,V> next);

---------------------------------------分割线--------------------------------

阅读ConcurrentHashMap源码记录--JDK8

sizeCtl是控制标识符，不同的值表示不同的意义。

• 负数代表正在进行初始化或扩容操作 
• -1代表正在初始化 
• -N 表示有N-1个线程正在进行扩容操作 
• 正数或0代表hash表还没有被初始化，这个数值表示初始化或下一次进行扩容的大小，类似于扩容阈值。它的值始终是当前ConcurrentHashMap容量的0.75倍，这与loadfactor是对应的。实际容量>=sizeCtl，则扩容。

    private final Node<K,V>[] initTable() {  
            Node<K,V>[] tab; int sc;  
      
            //这个有个死循环，  
            while ((tab = table) == null || tab.length == 0) {  
                //sizeCtl < 0 时表示已经有线程在初始化，让渡CPU，自旋。
                //何时赋值？继续看后面  
                if ((sc = sizeCtl) < 0)  
                    Thread.yield(); // lost initialization race; just spin  
                //1.这里有个if,如果没进这个if，则继续循环  
                //什么时候没进这个if呢？  
                //  -就是执行了unsafe.compareAndSwapInt，但初始化失败的时候，  
                //什么时候失败呢？  
                //  -当其他的线程也对sizeCtl进行了修改（内存里实际的值与手上拿的（新建map时设定的值）不一样，这个时候就返回false了。    svn一样？？？）  
                //2.如果有其他线程成功执行了CAS，内存中的sizeCtl的值也被修改成了-1，则进入if,放弃此次执行  
                //3.如果未成功，那继续while循环 
                //  -这个时候要么其他的线程已经将table初始化好了，table!=null，直接返回table就行了  
                //  -要么其他线程正在初始化这个表，此时的sizeCtl是-1.所以放弃此次执行。（等待其他线程）  
                else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {  
                    try {  
                        if ((tab = table) == null || tab.length == 0) {  
                            //这里就是初始化一个table数组  
                            int n = (sc > 0) ? sc : DEFAULT_CAPACITY;  
                            @SuppressWarnings("unchecked")  
                            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];  
                            table = tab = nt;  
                            sc = n - (n >>> 2);  
                        }  
                    } finally {  
                        //结束后将sizeCtl设置为新的table的容量（而不是-1）  
                        sizeCtl = sc;  
                    }  
                    //初始化完成了，那就break。  
                    break;  
                }  
            }  
            return tab;  
        }  

更新中----------

参考：

http://m.blog.csdn.net/u010887744/article/details/50637030

http://m.blog.csdn.net/u010723709/article/details/48007881

http://blog.csdn.net/q291611265/article/details/48004373

https://my.oschina.net/pingpangkuangmo/blog/817973

http://www.jianshu.com/p/f6730d5784ad