基于JDK1.8的ConcurrentHashMap中put相关部分源码分析（非红黑树部分）

ConcurrentHashMap基本介绍

ConcurrentHashMap是J.U.C中提供的一个线程安全高效的HashMap,是Map的派生类，所以API与HashMap相似。在本文主要基于JDK1.8来进行分析CHM，1.7与1.8 的主要区别在于：

1.7版本：

1.ConcurrentHashMap由一个个Segment 组成，Segment 继承ReentrantLock来进行加锁，通过锁住Segment 内操作来达到线程安全。
2.数据结构：数组+链表，在默认情况下可以支持16个线程进行并发操作。

1.8版本：

1.取消了Segment 分段操作，使用Node数组来保存数据，并且对Node数组元素作为锁来实现每一行数据数据进行加锁，来减少并发冲突概率。
2.数据结构：数组+链表+红黑树。当链表长度大于8时候采用红黑树，为的是降低查找时候的时间复杂度。

ConcurrentHashMap构造方法

public ConcurrentHashMap() {
   
}
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;
}
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
   
    this.sizeCtl = DEFAULT_CAPACITY;
    putAll(m);
}

在此主要列出了三个构造方法，ConcurrentHashMap(int i )创建实例时，通过判断传入参数的大小进行创建初始数组长度，如果小于MAXIMUM_CAPACITY >>> 1一位则对传入参数进行修改，使其修改为2幂次方。

MAXIMUM_CAPACITY初始值为 1<<30 即1左移30位 具体数值自己可以去写代码验证

ConcurrentHashMap.put

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();
    int hash = spread(key.hashCode());	//计算hash值
    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值计算对应数组下标，以volatile读的方式来读取table数组中的元素确保每次都是最新值。
       */
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
   
          /*如果该下标返回节点为空，则直接通过cas将新值封装成Node插入，如果cas失败则说明存在竞争进行自旋
          */
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                 
        }
   	...
     }

在这段代码主要是在调用initTable()进行数组初始化与casTabAt进行原子操作。假如存在两个两个线程执行casTabAt操作，如果A线程成功操作则B线程可通过tabAt 看到table[i] 的改变，因为casTabAt具有volatile相同语义。而initTable是数组初始化方法，其方法内容比较简单，可能会绕的是sizeCtl。sizeCtl是用来标记数组初始化扩容用的变量，当其为-1是说明在初始化，-N表示则有N-1个线程进行扩容，0表示还没有初始化，>0表示下次扩容大小。

private final Node<K,V>[] initTable() {
   
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
   //由于是初始化肯定都是空的
        if ((sc = sizeCtl) < 0)//默认为0，<0时表示已经进入初始化（不止一个线程）
            Thread.yield();
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
   //利用CAS将sizeCtl更新为-1,表示已经开始进行初始化
            try {
   
                if ((tab = table) == null || tab.length == 0) {
   
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;//DEFAULT_CAPACITY=16
                    @SuppressWarnings("unchecked")	//消除警告注释
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);//扩容用，16无符号右移2位是4 即sc为原来的0.75倍
                }
            } finally {
   
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

ConcurrentHashMap.addCount

在putVal最后，执行了addCount(1L, binCount)，binCont为链表长度

private final void addCount(long x, int check) {
   
    CounterCell[] as; long b, s;
    /*
    *判断counterCells是否为空
    *如果为空，则通过cas操作尝试修改BASECOUNT
    *如果cas失败，则采用CounterCell来记录
    */
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
   
        CounterCell a; long v; int m;
        boolean uncontended = true