ConcurrentHashMap解析

创建

 new ConcurrentHashMap();

官方建议加上初始化大小（前提你确定大小的情况下）， new ConcurrentHashMap(32);比如因为扩容是个很耗费资源的事情。

// 传入的初始化数组大小如果是32的话 最终结果是tableSizeFor(32+32/2+1) = 64
public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }

变量

  private transient volatile int sizeCtl;

sizeCtl为0 代表数组未初始化，且数组的初始容量为16

sizeCtl为正数，如果数组未初始化，那么其记录的是数组的初始容量，如果数组已经初始化，那么其记录的是数组的扩容阈值。

sizeCtl为-1 表示数组正在进行初始化

sizeCtl小于0 并且不是-1 表示数组正在扩容，-(1+n) 表示此时有n个线程正在共同完成数组的扩容操作。

put方法

final V putVal(K key, V value, boolean onlyIfAbsent) {
  	// concurrentHashMap key或者value都不能为null
        if (key == null || value == null) throw new NullPointerException();
  	// 对key的hashcode进行一定的扰动，并屏蔽符号位
        int hash = spread(key.hashCode());
  	// 记录数组中某个桶位元素的个数
        int binCount = 0;
  	// 注意：这里是一个for循环，for循环中代码较多，容易忘记
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
              	// 当数组还未初始化时，先初始化数组，concurrentHashMap，数组是延迟初始化的
                tab = initTable();
            // 这个桶位没有元素
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
              	// CAS设置元素，设置成功退出for循环
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                  
            }
            // 如果桶位中该元素的hash值为-1，表示数组正在扩容中，数组扩容下文有详细的解释
            else if ((fh = f.hash) == MOVED)
              	// 进行协助扩容
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
              	// 对该桶位进行加锁，保证线程安全，不会影响到其它桶位
                synchronized (f) {
                    // double check，防止该节点树化，这个节点如果还是原来的节点表示该节点没有更改过
                    if (tabAt(tab, i) == f) {
                      	// 普通链表节点
                        if (fh >= 0) {
                            // 注意：这里是从1开始
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                              	// 找到了一个与插入元素key完全一致的数据，进行value的更新
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                              	// 没有找到与插入元素key完全一致的数据，链表后新增节点
                                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) {
                    // 如果当前数组的长度大于等于64且链表上的节点超过9个，进行树化（binCount从1开始）
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    // 重复键，将旧值返回
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
  	// 添加的是新元素，维护数组元素个数
        addCount(1L, binCount);
        return null;
    }