ConcurrentHashMap（未完成）

1.sizeCtl

        1.sizeCtl = 0:数组未初始化，并且并没有传递初始值，默认初始容量为16
        2.sizeCtl > 0:如果没有进行初始化，记录的是初始容量，如果已经初始化则记录的是扩容阈值
            1.扩容阈值：数组长度*0.75
        3.sizeCtl = -1 表示正在进行初始化
        4.sizeCtl < 0 && sizeCtl != -1 : 正在扩容，-（1 + n）表示有n个线程正在同时完成扩容操作

2.初始化

//在第一次put()方法后才会进行初始化
public V put(K key, V value) {
     return putVal(key, value, false);
}

//table是真正存储数据的数组
//transient volatile Node<K,V>[] table;
final V putVal(K key, V value, boolean onlyIfAbsent) {
    //首次put判断table是否为空，如果为空则初始化
    //Node<K,V>[] tab = table
    if (tab == null || (n = tab.length) == 0)
        //table初始化
        tab = initTable();
}

    /**
     * Initializes table, using the size recorded in sizeCtl.
     */
    private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {

            //sizeCtl = -1 表示正在进行初始化
            //如果有sizeCtl = -1则表示别的线程正在初始化，则yield()
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin

            //否则当前线程进行CAS来修改sizeCtl的值为-1并且进行扩容操作
            //private static final sun.misc.Unsafe U;
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    //double check
                    //防止重复初始化
                    if ((tab = table) == null || tab.length == 0) {

                        //判断是否有赋初始值，没有则选择默认初始值
                        //private static final int DEFAULT_CAPACITY = 16;
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")

                        //初始化数组并赋值给table
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        
                        //扩容因子0.75
                        //设置扩容阈值
                        sc = n - (n >>> 2);
                    }
                } finally {
                    //将扩容阈值赋值给sizeCtl 
                    //sizeCtl > 0:如果没有进行初始化，记录的是初始容量，如果已经初始化则记录的        
                    //是扩容阈值
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

3.插入元素

    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());


        int binCount = 0;
        //插入
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;

            //1.如果table还未初始化则进行初始化
            if (tab == null || (n = tab.length) == 0)
                tab = initTable(); //初始化

            //2.tabAt()是通过CAS来取table中key对应的下标的对象并赋给f
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                
                //3.如果f为空则直接把node通过casTabAt（CAS）加入到table里面即可
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }

            //4.如果f不为空且f的hash值fh为MOVED则表示table该下标位置的元素正在进行扩容操作
            //static final int MOVED     = -1; // hash for forwarding nodes
            //当前元素无法插入需要helpTransfer进行辅助赋值
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);

            //5.如果f不为空且不为MOVED，则执行插入操作
            else {
                V oldVal = null;
                
                //对f进行上锁
                //f是其所在桶的链表头结点，可以保证每个线程加锁对象是一样的，保证插入安全
                synchronized (f) {
                    
                    //如果f所在桶的头节点不是f则表示该桶数据结构目前已经从链表转化成红黑树
                    if (tabAt(tab, i) == f) {

                        //fh >= 0表明该桶的数据结构是链表不是红黑树
                        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)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                //key不相同则插入到链表末尾
                                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;
                            }
                        }
                    }
                }

                //6.判断是否进行树化
                if (binCount != 0) {
                    //如果桶内结点数大于8则判断链表长度是否大于64
                    //链表长度小于64则进行扩容防止树化
                    //扩容大小为原数组大小的两倍
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        
        //7.维护集合长度
        //如果集合长度大于扩容阈值则进行扩容操作
        addCount(1L, binCount);
        return null;
    }