注：分析JDK8的ConcurrentHashMap，JDK6/7上的实现和JDK8上的不一样。

1.构造方法中的参数含义

构造方法中，有三个参数，如下，第三个参数才是一位数组的长度，第一个参数和第二个参数与Map的扩容有关

List-1

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)

构造方法如下List-2

List-2 initialCapacity的值不能小于concurrencyLevel，通过initialCapacity和loadFactor计算出值并赋值给sizeCtl

    public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)throw new IllegalArgumentException();if (initialCapacity < concurrencyLevel)   // Use at least as many binsinitialCapacity = concurrencyLevel;   // as estimated threadslong size = (long)(1.0 + (long)initialCapacity / loadFactor);int cap = (size >= (long)MAXIMUM_CAPACITY) ?MAXIMUM_CAPACITY : tableSizeFor((int)size);this.sizeCtl = cap;}

sizeCtl在哪用到了，如下图1所示，如果sizeCtl的值大于0，说明我们指定了capacity，所以不会使用默认的DEFAULT_CAPACITY。注意sizeCtl的值是容量，不是当前Map中元素的个数。

图1 初始化表

2.并发度，一维数组

一维数组存储在这个中，长度默认是16，即默认的ConcurrenyLevel。

List-2

transient volatile Node<K,V>[] table=(Node<K,V>[])new Node<?,?>[n];

Node的类结构如下所示：

List-3

static class Node<K,V> implements Map.Entry<K,V> {final int hash;final K key;volatile V val;volatile Node<K,V> next;Node(int hash, K key, V val, Node<K,V> next) {this.hash = hash;this.key = key;this.val = val;this.next = next;}
...
}

来看张ConcurrentHashMap的数据结构图，如下图1所示：

图1 ConcurrentHashMap的数据结构

如图1所示，当A对应的链表长度达到8后，就会转换为红黑树。为什么是8：属性TREEIFY_THRESHOLD上有注释，不过没怎么看懂。我个人觉得，如果链表长度小于8就转换为红黑树，效率上可能不如链表，毕竟红黑树的调整是比链表复杂的，这时不如直接使用链表；如果链表长度超过8，那么使用链表，查询效率会变低(最坏情况下遍历整条链表)，此时用红黑树那么就能将查询的复杂度由O(n)降低到LogN。

红黑树中的节点TreeNode：

List-4

static final class TreeNode<K,V> extends Node<K,V> {TreeNode<K,V> parent;  // red-black tree linksTreeNode<K,V> left;TreeNode<K,V> right;TreeNode<K,V> prev;    // needed to unlink next upon deletionboolean red;TreeNode(int hash, K key, V val, Node<K,V> next,TreeNode<K,V> parent) {super(hash, key, val, next);this.parent = parent;}
...
}

3.多线程进行put，如何保证线程安全

来看一张图，如下图2：

图2 putVal方法中

假设put(x)时，插入的bucket位置是图1中A对应的链表，那么会对A进行synchronized，这样就保证了同一时刻只有线程能访问synchronized的代码块，这个代码块中，有插入Node的操作，这样就保证了线程安全。

ConcurrentHashMap的get()方法是不需要加上synchronize的，因为很多关键的属性都有volatile修饰保证了可见性，所以get()方法上不加synchronize的情况下，也可以得到结果。

4.如何扩容的，什么时候扩容

问题1：每次进行put后，都会调用addCount方法，对Map中当前元素数量加1。之后会调用sumCount()方法获取Map中当前有多少个元素，如果等于或者大于sizeCtl的值，就会触发扩容。

如下这个方法中就是触发扩容的入口。

addCount(long x, int check)

如下这个属性与扩容有关。

private transient volatile Node<K,V>[] nextTable;

实现扩容的代码在如下方法中，实现起来很复杂，可以参考这篇文章。

transfer(Node<K,V>[] tab, Node<K,V>[] nextTab)

5.怎么实现统计Map中元素个数的功能

与俩个属性有关，如下:

    /*** Base counter value, used mainly when there is no contention,* but also as a fallback during table initialization* races. Updated via CAS.*/private transient volatile long baseCount;/*** Table of counter cells. When non-null, size is a power of 2.*/private transient volatile CounterCell[] counterCells;

注：counterCells的长度与CPU个数有关。

CounterCell类如下:

@sun.misc.Contended static final class CounterCell {volatile long value;CounterCell(long x) { value = x; }}

解说下这个baseCount和counterCells是如何工作的：

• 情况1： 假设只有一个线程进行put，Map中元素个数加1，会对baseCount进行CAS进行值加1，由于此时只有一个线程，所以CAS会成功，注意这里的是Unsafe的CAS，而不是AtomicInteger之类的CAS，所以如果失败会马上返回false。
• 情况2：假设有多个线程进行put，此时多个线程对baseCount进行CAS，此时若有些线程发生CAS失败，说明对baseCount竞争失败，注意这里使用的是Unsafe的CAS，而不是AtomicInteger之类的CAS，所以如果失败会马上返回false。此时从counterCells中随机选取一个出来，对CounterCell的value做CAS进行加1，如果此时发生CAS失败，说明碰到了竞争，怎么处理呢，看下图，将counterCells的数组长度翻倍，之后拷贝元素组的值到新数组中对应的位置。

调用size()时，会调用sumCount()，sumCount()方法实现如下：

    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;}

首先获得baseCount的值，之后遍历每个counterCells中的value，就是Map中的元素的值，当然，得到的这个值不一定准确、不是实时的。

JDK8的ConcurrentHashMap中计算Map中元素个数的方法与LongAddr、DoubleAdder很类似。

JDK8中获取size的实现，比JDK6/7中的要好很多了，如果你看过JDK6/7中ConcurrentHashMap的实现，应该会有所感受的