版权声明：本文为博主原创文章，转载请注明出处 https://blog.csdn.net/fei20121106/article/details/83301784
文章目录
ConcurrentHashMap 和 HashMap 的底层实现都是 数组+链表或红黑树 构成的。
HashMap 的源码分析见：Java集合框架——HashMap源码分析
ConcurrentHashMap 相比 HashMap 支持多线程下的操作。
而与 HashTable 相比，虽然 HashTable 也是线程安全的，但是其大量使用的是 synchronized 关键字，锁的粒度比较大，导致多线程下效率受影响。
ConcurrentHashMap 加锁粒度在数组中的每个桶，所以在多线程环境下，并不影响其他线程的操作。
一、属性
// 最大容量，2的30次方
private static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认的初始容量为16，其必须为2的整数次方
private static final int DEFAULT_CAPACITY = 16;
// 最大数组容量，最大整数减8（这个值和ArrayList的底层数组原理一致）
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 默认并发级别（未使用但为与该类以前版本兼容）
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 默认的加载因子
private static final float LOAD_FACTOR = 0.75f;
// Java8中链表转树的阈值8
static final int TREEIFY_THRESHOLD = 8;
// Java8中树转链表的阈值6
static final int UNTREEIFY_THRESHOLD = 6;
// Java8中转树时数组容量最小值
// 当桶数量太小时，而一个桶中超过8个，此时应该先数组扩容而不是转树
// 为了避免转树还是扩容的冲突，这个值不能小于4*TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;
// 每次转移的最小值
private static final int MIN_TRANSFER_STRIDE = 16;
// 生成sizeCtl所使用的bit位数
private static int RESIZE_STAMP_BITS = 16;
// 进行扩容所允许的最大线程数
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 记录sizeCtl中的大小所需要进行的偏移位数
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
// 一系列的标识
static final int MOVED = -1; // hash for forwarding nodes
static final int TREEBIN = -2; // hash for roots of trees
static final int RESERVED = -3; // hash for transient reservations
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
// 获取可用的CPU个数
static final int NCPU = Runtime.getRuntime().availableProcessors();
// 进行序列化的属性
private static final ObjectStreamField[] serialPersistentFields = {
new ObjectStreamField("segments", Segment[].class),
new ObjectStreamField("segmentMask", Integer.TYPE),
new ObjectStreamField("segmentShift", Integer.TYPE)
};
// 节点数组
transient volatile Node<K,V>[] table;
// 扩容时的新数组
private transient volatile Node<K,V>[] nextTable;
// 基本计数
private transient volatile long baseCount;
// 对表初始化和扩容控制
// 当为负数时：-1代表正在初始化，-N代表有N-1个线程正在进行扩容
// 当为0时：代表当时的table还没有被初始化
// 当为正数时：表示初始化或者下一次进行扩容的大小
private transient volatile int sizeCtl;
// 扩容下另一个表的索引
private transient volatile int transferIndex;
// 自旋锁
private transient volatile int cellsBusy;
// counterCell表
private transient volatile CounterCell[] counterCells;
// 视图
private transient KeySetView<K,V> keySet;
private transient ValuesView<K,V> values;
private transient EntrySetView<K,V> entrySet;
// Unsafe实例，主要用于反射获取对象相应的字段。
private static final sun.misc.Unsafe U;
private static final long SIZECTL;
private static final long TRANSFERINDEX;
private static final long BASECOUNT;
private static final long CELLSBUSY;
private static final long CELLVALUE;
private static final long ABASE;
private static final int ASHIFT;
static {
try {
U = sun.misc.Unsafe.getUnsafe();
Class<?> k = ConcurrentHashMap.class;
SIZECTL = U.objectFieldOffset
(k.getDeclaredField("sizeCtl"));
TRANSFERINDEX = U.objectFieldOffset
(k.getDeclaredField("transferIndex"));
BASECOUNT = U.objectFieldOffset
(k.getDeclaredField("baseCount"));
CELLSBUSY = U.objectFieldOffset
(k.getDeclaredField("cellsBusy"));
Class<?> ck = CounterCell.class;
CELLVALUE = U.objectFieldOffset
(ck.getDeclaredField("value"));
Class<?> ak = Node[].class;
ABASE = U.arrayBaseOffset(ak);
int scale = U.arrayIndexScale(ak);
if ((scale & (scale - 1)) != 0)
throw new Error("data type scale not a power of two");
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
} catch (Exception e) {
throw new Error(e);
}
}
二、主要构造函数
创建一个带有指定初始容量、加载因子和并发级别的新的空映射。
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel)
initialCapacity = concurrencyLevel;
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
会根据输入的 initialCapacity 的大小来确定一个最小的且大于等于 initialCapacity 大小的 2 的 n 次幂。
构造函数中的 concurrencyLevel 参数已经在JDK8 中的意义发生了很大的变化，其并不代表所允许的并发数，其只是用来确定 sizeCtl 大小，在 JDK8 中的并发控制都是针对具体的桶而言，即有多少个桶就可以允许多少个并发数。
三、主要方法
3.1 putVal
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 键或值为null，抛空指针异常
if (key == null || value == null) throw new NullPointerException();
// 获取hash值，spread的算法下面说
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)
// 数组为null或者长度为0，初始化数组
tab = initTable();
// 如果数组不为空，而且hash值对应存放的下标的桶为空
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 使用CAS将该节点存放与该下标的空桶中（空桶中添加数据不用加锁）
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break;
}
else if ((fh = f.hash) == MOVED)
// 如果该hash值为-1，节点需要转移，在扩容的过程中
tab = helpTransfer(tab, f);
else {
// 正常情况下
V oldVal = null;
// 对桶中的第一个节点加同步锁
synchronized (f) {
if (tabAt(tab, i) == f) {
// 节点的hash值大于0
if (fh >= 0) {
binCount = 1;
// 无限循环，对链表进行遍历查找
// 从第一个节点开始遍历，一直到最后一个节点，每走一个节点binCount加1
// 如果中间找到相等的就做值替换，找不到就在最后加上新节点
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
// 节点的hash相等并且key也相等，做值替换即可
// 保存旧值
oldVal = e.val;
// onlyIfAbsent一般为false，这里替换为新值
if (!onlyIfAbsent)
e.val = value;
break;
}
// 当前节点
Node<K,V> pred = e;
// 如果当前节点的下一个节点为null，说明已经是最后节点，可以再其后添加新节点
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;
}
}
}
}
// binCount不为0说明发生了更新或结构变化
if (binCount != 0) {
// 如果binCount大于等于阈值8，说明新加节点后，肯定超过阈值8了，那么就要转化为红黑树
if (binCount >= TREEIFY_THRESHOLD)
// 对数组中下标i处的单链表转为红黑树
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 统计size，并且检查是否需要扩容
addCount(1L, binCount);
return null;
}
3.1.1 initTable
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// sizeCtl小于0，说明其他线程正在进行初始化或者扩容操作，则当前线程必须让步等待
if ((sc = sizeCtl) < 0)
Thread.yield();
// 比较SIZECTL和sizeCtl的值是否相等，如果相等则用-1替换
// -1表示正在初始化，即当前线程正在初始化
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
// sc大于0的话，就取sc的值作为容量
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 生成节点数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// 数组容量的0.75倍
sc = n - (n >>> 2);
}
} finally {
// 设置sizeCtl的值（数组容量的0.75倍）
sizeCtl = sc;
}
break;
}
}
return tab;
}
3.1.2 tabAt
返回 table 数组中下标为i的结点
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
3.1.3 casTabAt
比较 table 数组下标为 i 的节点是否为 c ，若为 c，则用 v 交换。否则，不进行交换操作。
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
3.1.4 helpTransfer
helpTransfer 方法为协助扩容方法，当调用该方法的时候，nextTable 一定已经创建了，所以该方法主要则是进行复制工作。
其中 ForwardingNode 是一个特殊的 Node 节点，hash 值为 -1，其中存储 nextTable 的引用。只有 table 发生扩容的时候，ForwardingNode 才会发挥作用，作为一个占位符放在 table 中表示当前节点为 null 或则已经被移动。
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
int rs = resizeStamp(tab.length);
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
3.1.5 addCount
addCount 方法主要是给 baseCount 值加 1 的操作，同时判断是否要进行扩容。