并发容器集合ConcurrentHashMap

前序

在java.util包下提供了一些线程安全的容器类，如Vector和HashTable。但这些容器是通过sychronized实现实现同步，这样读写均需要锁操作，导致性能低下。Java提供了一些代替同步容器的并发容器，使用这些容器可以提高并发访问性。

 

---

ConcurrentMap接口

ConcurrentMap接口继承了Map接口，在Map接口的基础上又定义了4个方法：

public interface ConcurrentMap<K, V> extends Map<K, V> {

    //插入元素
    /*
        与原有的put方法不同在于：该方法中若插入的key值不同，则不替换原有的value值
    */
    V putIfAbsent(K key, V value);

    //移除元素
    /*
        与原有的remove方法不同在于：该方法增加了对value的判断，如果要删除的key-value
        不能与Map中原有的key-value对应上，则不会删除该元素;
    */
    boolean remove(Object key, Object value);

    //替换元素.
    /*
        该方法增加了对value的判断，如果key-value
        能与Map中原有的key-value对应上，才进行替换操作;
    */
    boolean replace(K key, V oldValue, V newValue);

    //替换元素
    /*
        与上面方法不同的是：该方法不会对Map中原有的key-value进行比较，若key存在则直接替换
    */
    V replace(K key, V value);

}

 

 

---

ConcurrentHashMap类

线程不安全的HashMap

在并发编程中使用HashMap可能导致程序死循环，这是因为多线程会导致HashMap的Entry链表形成环形数据结构，即Entry的next节点永不为空，进而产生死循环获取Entry。

效率低下的HashTable

HashTable容器使用synchronized来保证线程安全，当一个线程访问HashTable的同步方法，其他线程会被进入阻塞或轮询状态，如线程1使用put进行元素添加，线程2不但不能使用put方 法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。

ConcurrentHashMap的锁分段技术

HashTable效率低下的原因是所有访问HashTable的 线程都必须竞争同一把锁，而ConcurrentHashMap的锁分段技术将数据分成一段一段的存储，给每一段数据配一把锁，这样当一个线程占用锁访问其中一个段数据的时候，其他段的数 据也能被其他线程访问。

 

JDK 1.7下的ConcurrentHashMap

ConcurrentHashMap在JDK 1.7中采用了数组+Segment+分段锁的方式实现，Segment是一个继承自ReentrantLock的锁，Segment数组维护了HashEntry的数组table。HashEntry本质是一个K-V存储结构，内部存储了目标对象的Key和Value，同时HashEntry也是一个链式结构，内部维护了下一个HashEntry的变量next。

分段锁机制将数据分段，对每一段数据分配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。对于一些方法需要跨段，比如说size()、isEmpty()、containsValue()，它们可能需要锁定整个表而非某个段，因此需要按顺序锁定所有段，操作完后按顺序释放所有的锁。

ConcurrentHashMap大致结构

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
        implements ConcurrentMap<K, V>, Serializable {

        static final int DEFAULT_INITIAL_CAPACITY = 16;
        /**
         * 默认的负载因子为0.75
         */
        static final float DEFAULT_LOAD_FACTOR = 0.75f;

        static final int DEFAULT_CONCURRENCY_LEVEL = 16;

        final Segment<K,V>[] segments;

   static final class Segment<K,V> extends ReentrantLock implements Serializable {
         transient volatile HashEntry<K,V>[] table;
         ...
    }

    static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry<K,V> next;
    }

}

 

ConcurrentHashMap的初始化

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    // Find power-of-two sizes best matching arguments
    int sshift = 0;
    int ssize = 1;
    //设置segments数组长度
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    //计算每一个segment中table的数量cap
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
    // create segments and segments[0]
    Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                    (HashEntry<K,V>[])new HashEntry[cap]);
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

我们将构造函数分为两部分：

（1）设置segments数组长度

构造函数中第三个参数concurrencyLevel默认为DEFAULT_CONCURRENCY_LEVEL的值 ，即16。

Segment数组的最终大小ssize一定是大于或等于concurrentLevel的最小的2的次幂。

if (concurrencyLevel > MAX_SEGMENTS)
   concurrencyLevel = MAX_SEGMENTS;
    int sshift = 0;
/*
    当我们put进一个key-value对象HashEntry时，是通过key的哈希码 & segments[].length - 1来得到
    放入segments数组的下标值。因此我们需要控制segments数组的大小要大于等于concurrencyLevel
    的最小2的n次方数
*/
    int ssize = 1;
        while (ssize < concurrencyLevel) {
              ++sshift;
            ssize <<= 1;
        }
    segmentShift = 32 - sshift;
    // segmentMask = segments[].length - 1
    segmentMask = ssize - 1;
    this.segments = Segment.newArray(ssize);

（2）初始化每个segment中的HashEntry数组数量

方法的第一个参数initialCapacity默认为DEFAULT_INITIAL_CAPACITY 的值，即16，它表示HashEntry数组的总共大小，ssize则是segment数组大小。
变量c = initialCapacity / ssize，它表示每个segment的HashEntry数组数量。如果c大于1，就会取大于等于c的2的N次方值，因此cap最小为2，即每个segment最少有两个HashEntry数组

if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
        int c = initialCapacity / ssize;
        if (c * ssize < initialCapacity)
            ++c;
        int cap = 1;
        while (cap < c)
            cap <<= 1;
        for (int i = 0; i < this.segments.length; ++i)
            this.segments[i] = new Segment<K,V>(cap, loadFactor);

 

put操作

put操作主要分为两步：

（1）定位到放入segment数组的下标j，并确保该位置已被初始化；

（2）调用segment的put方法

public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject          
             (segments, (j << SSHIFT) + SBASE)) == null) 
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
}

然后是segment对象的put方法：

（1）由于put方法需要对共享变量进行写入操作，因此需要加锁。该节点通过tryLock()方法尝试加锁，若不成功表示当前锁已被其他线程持有，则执行scanAndLockForPut()方法：在scanAndLockForPut方法中，会通过重复执行tryLock()方法尝试获取锁，如果执行tryLock()方法次数超过上限后，会执行lock()方法挂起当前线程，等待其他线程unlock()。

（2）根据HashEntry[].length - 1 & hash来得到HashEntry数组的下标index，然后放入对应的HashEntry数组里。

（3）判断Segment里的HashEntry数组是否超过阈值（threshold），如果超过，则对数组进行扩容。

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) {
                        K k;
                        if ((k = e.key) == key ||
                            (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;
                    }
                    else {
                        if (node != null)
                            node.setNext(first);
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
//若c超出阈值threshold，需要扩容并rehash。
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
}

 

get方法

由于get方法只需要读且涉及到的共享变量都使用volatile修饰，因此无需加锁。

public V get(Object key) {
        Segment<K,V> s; 
        HashEntry<K,V>[] tab;
        int h = hash(key);
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        //先定位Segment，再定位HashEntry
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
            (tab = s.table) != null) {
            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                     (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
                 e != null; e = e.next) {
                K k;
                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                    return e.value;
            }
        }
        return null;
    }

 

JDK 1.8下的ConcurrentHashMap

JDK1.8的ConcurrentHashMap采用的节点Node数组+链表/红黑树+CAS+synchronized来保证并发安全。

ConcurrentHashMap的大致结构如下。

（1）Node类包装了key-value键值对，所有插入ConcurrentHashMap的数据都包装在这里面。它不允许调用setValue方法直接改变Node的value域。

（2）当链表长度过长的时候，会转换为TreeNode。与HashMap不相同的是，它并不是直接转换为红黑树，而是把这些结点包装成TreeNode放在TreeBin对象中，由TreeBin完成对红黑树的包装。TreeNode继承自Node类。

（3）TreeBin类负责包装很多的TreeNode节点，在实际的ConcurrentHashMap“数组”中，存放的是TreeBin对象，而不是TreeNode对象。

（4）ForwardingNode类用于连接两个table，它包含一个nextTable指针，用于指向下一张表。

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {
    
    static final int MOVED     = -1; //  hash值是-1，表示这是一个forwardNode节点
    static final int TREEBIN   = -2; //  hash值是-2  表示这时一个TreeBin节点

//当插入新数据put()或则删除数据remove()时，会通过addCount()方法更新baseCount
    private transient volatile long baseCount; 

    private transient volatile CounterCell[] counterCells;
    transient volatile Node<K,V>[] table;

    /**
     * 控制标志符
     * 负数: 代表正在进行初始化或扩容操作，其中-1表示正在初始化，-N 表示有N-1个线程正在进行扩容操作
     * 正数或0: 代表hash表还没有被初始化，这个数值表示初始化或下一次进行扩容的大小，类似于扩容阈值
     * 它的值始终是当前ConcurrentHashMap容量的0.75倍，这与loadfactor是对应的。
     * 实际容量 >= sizeCtl，则扩容
     */
    private transient volatile int sizeCtl;
    ...
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;
        ...
    }

    static final class TreeNode<K,V> extends Node<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
       ...
    }
    
    static final class TreeBin<K,V> extends Node<K,V> {
        TreeNode<K,V> root;
        volatile TreeNode<K,V> first;
        volatile Thread waiter;
        volatile int lockState;
        // values for lockState
        static final int WRITER = 1; // set while holding write lock
        static final int WAITER = 2; // set when waiting for write lock
        static final int READER = 4; // increment value for setting read lock
        ...
    }
    static final class ForwardingNode<K,V> extends Node<K,V> {
        final Node<K,V>[] nextTable;
        ...
    }
}
    

 

初始化方法initTable

对于ConcurrentHashMap来说，调用它的构造方法仅仅是设置了一些参数。而整个table的初始化是在向ConcurrentHashMap中插入元素时发生的。如调用put、computeIfAbsent、compute、merge等方法的时候。

初始化方法主要用了sizeCtl 变量，若该变量小于0，表示其他线程正在进行初始化，则通过yield方法让出CPU。如果获得了初始化权限，就用CAS方法将sizeCtl置为-1，防止其他线程进入。初始化数组后，将sizeCtl的值改为0.75*n。

private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
//sizeCtl表示有其他线程正在进行初始化操作，把线程挂起。
//对于table的初始化工作，只能有一个线程在进行。
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
利用CAS方法把sizectl的值置为-1 表示本线程正在进行初始化
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        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);//相当于0.75*n 设置一个扩容的阈值
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

 

扩容方法 transfer

什么时候扩容

当往hashMap中成功插入一个key/value节点时，有可能触发扩容动作：

（1）桶中链表长度达到阔值8，但整个ConcurrentHashMap节点数量小于64

（2）新增节点之后，整个ConcurrentHashMap节点数量超过阈值。

扩容操作分为两步骤：

1. 构建一个容量是原来两倍的nextTable，此步骤是单线程完成的；
2. 将原来table中的元素复制到nextTable中，此步骤允许多线程进行操作。

    private final void transfer(Node[] tab, Node[] nextTab) {
        int n = tab.length, stride;
        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数组，容量为当前的两倍
                Node[] nt = (Node[])new Node[n << 1];
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                // 若扩容时出现OOM异常，则将阈值设为最大，表明不支持扩容
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            transferIndex = n;
        }
        int nextn = nextTab.length;
        // 创建ForwardingNode节点，作为标记位，表明当前位置桶已做过处理
        ForwardingNode fwd = new ForwardingNode(nextTab);
        boolean advance = true;
        boolean finishing = false; 
        for (int i = 0, bound = 0;;) {
            Node f; int fh;
            while (advance) {
                int nextIndex, nextBound;
                if (--i >= bound || finishing)
                    advance = false;
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                //通过CAS设置transferIndex属性值，并初始化i和bound值
                //i指当前处理的槽位序号，bound指需要处理的槽位边界
                //先处理最后一个桶的节点；
                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;
                //如果所有的节点都已经完成复制工作  就把nextTable赋值给table 清空临时对象nextTable
                if (finishing) {
                    nextTable = null;
                    table = nextTab;
                    //设置新扩容阈值
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                //利用CAS方法更新扩容阈值，在这里面sizectl值减一，说明新加入一个线程参与到扩容操作
                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 {
                //锁住i位置上桶的节点
                synchronized (f) {
                    //确保f是i位置上桶的节点
                    if (tabAt(tab, i) == f) {
                        Node ln, hn;
                        //当前桶是链式结构
                        if (fh >= 0) {
                            //构造两个链表
                            int runBit = fh & n;
                            Node lastRun = f;
                            //类似于1.8HashMap，只需要看新增的1bit是0还是1进行分类
                            for (Node p = f.next; p != null; p = p.next) {
                                //n是就数组长度，不是长度-1
                                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 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(ph, pk, pv, ln);
                                else
                                    hn = new Node(ph, pk, pv, hn);
                            }
                            //在nextTable的i位置上插入一个链表
                            setTabAt(nextTab, i, ln);
                            //在nextTable的i+n的位置上插入另一个链表
                            setTabAt(nextTab, i + n, hn);
                            //在table的i位置上插入forwardNode节点  表示已经处理过该节点
                            setTabAt(tab, i, fwd);
                            //设置advance为true 返回到上面的while循环中 就可以执行i--操作
                            advance = true;
                        }
                        //当前桶是红黑树结构，操作和上面的类似
                        else if (f instanceof TreeBin) {
                            TreeBin t = (TreeBin)f;
                            TreeNode lo = null, loTail = null;
                            TreeNode hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode p = new TreeNode
                                    (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;
                                }
                            }
                            //如果扩容后已经不再需要tree的结构 反向转换为链表结构
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }

 

get方法

    public V get(Object key) {
        Node[] tab; Node e, p; int n, eh; K ek;
        //计算hash值
        int h = spread(key.hashCode());
        //根据key.hashCode & table[].length - 1来确定节点位置，
        //通过tabAt方法获取该位置的Node节点e，判断节点类型
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            //桶首节点的key与查找的key相同，再判断一下key是否相同
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            //如果节点e的哈希值eh小于0，表示它是一个树节点
            else if (eh < 0)
                return (p = e.find(h, key)) != null ? p.val : null;
            //否则是一个链表节点
            while ((e = e.next) != null) {
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;
    }

 

put方法

大致流程为：

（1）由于ConcurrentHashMap不允许key或value为null，因此首先判断key和value是否为null。这是因为ConcurrentHashMap支持并发，如果通过get(key)获取对应的value是null时，我们无法区分它是put(key,value)的时候value就是null，还是key没有映射的情况。HashMap是非并发的，可以通过contains(key)来做这个判断；而支持并发的Map在调用map.contains（key）和map.get(key)，map可能已经变化了。

（2）重新计算hash值，然后判断当前table是否为空，若为空则初始化table。通过table.length - 1 & hash 得到位置i。通过tabAt方法获取对应位置节点，若没有节点则则直接添加新节点。

（3）判断得到的节点类型，若是ForwardingNode节点，表明有其它线程正在扩容，则一起进行扩容操作；若是链表或树节点，则按照不同的方式插入或更新节点。

（4）若新增节点后链表长度大于8，就把这个链表转换成红黑树。然后节点数量+1，校验是否超过阈值，若超过则扩容。

  public V put(K key, V value) {
        return putVal(key, value, false);
    }

    final V putVal(K key, V value, boolean onlyIfAbsent) {
//ConcurrentHashMap不允许key或value为null
        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;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
//若table.length - 1 & hash得出的位置i上的节点为null，则CAS插入新Node节点。
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
//        若当前正在扩容
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
//        锁住当前位置i的节点f
                synchronized (f) {
    //        为防止之前被其他线程修改，需要判断节点f是否为数组下标i的节点。
                    if (tabAt(tab, i) == f) {
        //        如果当前节点是链表节点
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
        //若hash值与key值相同，则替换旧值
                                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;
                 //若链表中找不到，在链表尾部插入界定啊
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                    //若节点f是树节点，则遍历红黑树
                        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) {
                 //若链表长度超过默认值8，将链表转为红黑树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
//节点数+1，若超过阈值则扩容
        addCount(1L, binCount);
        return null;
    }

 

size方法

在多线程环境下，ConcurrentHashMap的table数量是不确定的，因此该方法返回的是个估计值。

其中元数个数保存在baseCount，部分元素的变化个数保存在CounterCell数组counterCells中，通过累加baseCount和CounterCell数组中的数量，即可得到元素的总个数；

    public int size() {
        long n = sumCount();
        return ((n < 0L) ? 0 :
                (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
                (int)n);
    }
    
    final long sumCount() {
        CounterCell[] as = counterCells; CounterCell a;
        long sum = baseCount;
        if (as != null) {
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

 

 

---

参考资料

https://www.cnblogs.com/duanxz/archive/2012/10/08/2714933.html
https://juejin.im/post/5b53d1adf265da0f70070e3d#heading-0