ConcurrentHashMap不仅实现了多线程的同步读写而且轻量级，这是它相比于HashMap和HashTable的优势。HashMap是线程不安全的，它没有提供任何的同步机制，多线程并发访问会有问题。HashTable虽然提供了同步机制，但是它是通过整个对象加锁达到同步的，是重量级的，并发性较低。下面将通过put()和get()方法，分析ConcurrentHashMap的主要实现。
一、ConcurrentHashMap的设计
ConcurrentHashMap将所有的key-value抽象封装在Node类中，数据存储结构是这样的：整体上分桶(table[i])，将不同散列值的key-value存放在数组table[]的不同位置，即：放在不同的桶中；散列值一样的key-value将以链表或者红黑树的结构存放在同一个桶中。数据并发一致性通过对桶加锁和CAS机制实现。本文不分析红黑树的初始化、存储与删除相关代码，ConcurrentHashMap红黑树相关代码也是其作者改编自CLR，相关算法可参考红黑树详解。
二、ConcurrentHashMap的构造函数
这里分析ConcurrentHashMap(int initialCapacity)；构造函数，其它构造函数大同小异。
1、ConcurrentHashMap中的成员变量介绍：有许多核心的概念要在分析源码之前介绍一下，写在源码注释中：
//哈希表的最大长度
private static final int MAXIMUM_CAPACITY = 1 << 30;
//哈希表默认长度
private static final int DEFAULT_CAPACITY = 16;
//负载因子，在哈希表的容量大于数组长度的3/4时会触发扩容
private static final float LOAD_FACTOR = 0.75f;
//当哈希表桶中链表过长的时候，会触发树化，即在链表长度大于8的时候，链表会转化为红黑树
//理想状态下，每个桶中元素的数量是符合泊松分布的，在负载因子为0.75时，一个桶中元素个数大于8个的概率在千万分之一，
//可以忽略不计，所以设计合理的哈希表树化的概率是很低的
static final int TREEIFY_THRESHOLD = 8;
//在扩容时，发现树的长度小于6，红黑树会退化为链表
static final int UNTREEIFY_THRESHOLD = 6;
//链表树化的条件还要数组长度大于64，虽然桶中元素大于8个，但是数组长度小于64是不会树化的，防止哈希表设计不合理导致树化
static final int MIN_TREEIFY_CAPACITY = 64;
//多个线程是可以同时辅助扩容的，一个线程最低扩容的区间长度为16
private static final int MIN_TRANSFER_STRIDE = 16;
//用来辅助计算sizeCtl值的，在下面的resizeStamp()函数中会介绍
private static final int RESIZE_STAMP_BITS = 16;
//在扩容时辅助计算sizeCtl的值，用来表示当前正在扩容的线程数
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
//ForwardingNode的hash值，代表该节点已经扩容完成了，节点已经被转移到了新的数组中
static final int MOVED = -1;
//红黑树的节点(TreeBin)的hash值
static final int TREEBIN = -2;
//掩码，辅助计算散列值，确保散列值为正数
static final int HASH_BITS = 0x7fffffff;
//机器CPU核心数，在扩容时辅助判断最多同时工作的线程数
static final int NCPU = Runtime.getRuntime().availableProcessors();
//哈希表中所有的节点存在该数组中，把每一个位置称为一个桶
transient volatile Node<K,V>[] table;
//扩容时新的数组，用于将table中的数据copy到该表中
private transient volatile Node<K,V>[] nextTable;
//大于0的时候，如果还未初始化table，则代表了数组长度，否则代表哈希表的容量(数组长度的3/4)
//-1是数组正在被初始化
//小于-1的时候，用来表示当前有多少个线程在扩容，此时该值是resizeStamp()函数计算出来的，
//后16位的实际数值减1代表正在扩容的线程(sizeCtl & 0xffff - 1)，后面会具体介绍
private transient volatile int sizeCtl;
2、ConcurrentHashMap(int initialCapacity)构造函数：传入了哈希表初始数组长度值，然后根据该值计算sizeCtl 的值。
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
//不大于最大容量时，根据initialCapacity计算数组的初始长度。
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
3、tableSizeFor()函数，用来计算大于c的最小的2^n方的一个数值，因为数组长度只能是2的幂次方，所以，该方法可以用来找到符合要求的数组长度值。
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
三、ConcurrentHashMap的put()方法
1、put()方法调用了putVal()：
该方法主体流程如下：
①如果数组还没有初始化，则先初始化数组，长度为sizeCtl；
②计算散列值，找到在数组中的位置，如果该位置为null，代表还没有数据放入，则直接将key-value封装成Node节点，放到该位置；
③如果该位置hash==MOVE，代表数组正在扩容，且此位置已经被移动到新数组中，则让该线程去辅助扩容；
④该位置是一个链表，找到链表相应的位置插入节点或者更新节点，在插入后，如果长度大于8，要将链表转换为红黑树；
⑤该位置是一棵红黑树，则将节点插入树中，或者更新树中的节点。
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
//根据key的hashCode值，计算hash值
int hash = spread(key.hashCode());
int binCount = 0;
//这里是一个for循环，停止条件在循环里面，防止一些由于CAS失败(初始化数组等)导致插入数据失败
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//初始化数组
if (tab == null || (n = tab.length) == 0)
tab = initTable();
//(n - 1) & hash)计算应该散列值，拿到该位置的数据
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;
//可以看到锁的粒度比较细，没有通过对整个表的加锁完成同步，而是对每一个桶进行加锁，这样可以达到桶级别的并行化
synchronized (f) {
if (tabAt(tab, i) == f) {
//hash值大于0，说明该位置是一个链表
if (fh >= 0) {
//记录链表长度
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-value插入到链表尾部
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;
}
}
else if (f instanceof ReservationNode)
throw new IllegalStateException("Recursive update");
}
}
if (binCount != 0) {
//链表长度大于8，树化链表
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
//哈希表中实际存储数据长度加1
addCount(1L, binCount);
return null;
}
2、spread()方法计算hash值：将hashCode右移16位，然后再异或，这样对hash值做了一次扰动，因为计算的散列值通常由低位起决定作用(hash&table.legth)，经过扰动之后，高位也可以对hash值起到一定的影响，& HASH_BITS之后，保证值为正数。
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
3、initTable()初始化数组：
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
Thread.yield(); //长度小于0，出错，放弃线程执行
//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;
//将容量设置为数组长度的3/4
sc = n - (n >>> 2);
}
} finally {
//将容量设置为数组长度的3/4
sizeCtl = sc;
}
break;
}
}
return tab;
}
4、helpTransfer()函数，用来辅助扩容的函数
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
//扩容时，旧数组table中放入的节点是ForwardingNode类型，nextTable是扩容时新建的数组，将旧数组中的数据拷贝到该数组中
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) {
//数组没有还未被扩容的区间或者sizeCtl值有变化，则线程不需要去辅助扩容
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
//将sizeCtl加1，代表即将又有一个线程去辅助扩容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
//实际执行扩容的函数
transfer(tab, nextTab);
break;
}
}
//完成了扩容，返回新数组
return nextTab;
}
//没有去辅助扩容，返回旧的数组
return table;
}
5、分析resizeStamp()函数：参数n一般就是数组长度，RESIZE_STAMP_BITS 是16，Integer.numberOfLeadingZeros(n)函数用于计算一个int型值二进制中第一个1前面0的个数，然后将该值的第16位置1，在左移16位之后(赋值给sizeCtl)，保证是一个负数。如n=16，前置0的个数是27(11011)个，则返回值为00000000000000001000000000011011。
static final int resizeStamp(int n) {
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
public static int numberOfLeadingZeros(int i) {
// HD, Figure 5-6
if (i == 0)
return 32;
int n = 1;
if (i >>> 16 == 0) { n += 16; i <<= 16; }
if (i >>> 24 == 0) { n += 8; i <<= 8; }
if (i >>> 28 == 0) { n += 4; i <<= 4; }
if (i >>> 30 == 0) { n += 2; i <<= 2; }
n -= i >>> 31;
return n;
}
6、treeifyBin()函数，将链表结构转化为红黑树：
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n;
if (tab != null) {
//虽然桶中长度大于8，但是数组长度小于64，则去扩容，而不是转化成红黑树
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1);
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) {
if (tabAt(tab, index) == b) {
TreeNode<K,V> hd = null, tl = null;
for (Node<K,V> e = b; e != null; e = e.next) {
//将链表的Node节点转化成TreeNode节点
TreeNode<K,V> p =
new TreeNode<K,V>(e.hash, e.key, e.val,
null, null);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
//TreeBin的构造函数中会生成红黑树的结构
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
7、tryPresize()扩容从这里开始，进行扩容前的准备，该函数在正在扩容的时候只会执行一次while 里的循环，它的作用是开启一次扩容。
private final void tryPresize(int size) {
//计算扩容后数组长度，为现在数组长度的2倍
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
//sizeCtl<0说明已经在扩容了，则放弃返回，可以防止该函数在扩容的时候被执行多次
while ((sc = sizeCtl) >= 0) {
Node<K,V>[] tab = table; int n;
//数组还未初始化，去初始化
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
//直到数组长度小于容量才返回，如c=32，n=16，扩容后n=32，sizeCtl=48，扩容前sizeCtl=24，sizeCtl代表了下次扩容的时候的容量
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
else if (tab == table) {
//计算一个标记，n=16时，返回值`00000000000000001000000000011011`，
//将其左移16位加2后赋值给sizeCtl，此时值为`1000000000011011 0000000000000010`，
//可以看见sizeCtl的低16位代表了扩容时的线程数+1
int rs = resizeStamp(n);
if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
8、transfer()真正执行扩容的地方，该函数主要实现流程是：
①根据CPU数，计算每个线程扩容的区间大小，最小为16；
②初始化一个新数组，用于扩容，长度是旧数组的2倍；
③进入一个循环，计算每个线程负责转移的区间；
④将数据从旧数组搬到新数组，根据链表和红黑树执行不同的操作；
⑤转移完毕，将table指向新的数组，整个扩容完成。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
//根据CPU核心数，计算每个线程负责的区间长度，最小为16，防止占用过多CPU
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE;
//初始化一个新的数组，长度为旧数组的2倍
if (nextTab == null) {
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
//该值标记线程转移区间的尾部
transferIndex = n;
}
int nextn = nextTab.length;
//旧数组中的节点转移到新数组之后，旧数组的该节点设置fwd，该节点hash=MOVE
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
//循环标志，用来找到该线程负责的转移区间和将转移下标前移(--i)
boolean advance = true;
//确认旧数组中所有元素已经转移到新数组中，然后将table指向新数组
boolean finishing = false;
//i是当前转移的数组下标，bound 为线程负责区间的头位置
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
//--i，将转移节点向前移
//区间被转移完毕，或者finishing = true时推出循环
if (--i >= bound || finishing)
advance = false;
//数组已经被线程分解完毕，退出
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//将transferIndex的值向前移stride长度，转移区间前移，可见整个转移顺序是从数组尾部以stride为单位向前进行的
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;
//扩容完成之后提交所有修改
if (finishing) {
nextTable = null;
table = nextTab; //重新指向新数组
sizeCtl = (n << 1) - (n >>> 1); //容量为新数组的3/4
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
//在只剩一个线程在执行扩容的时候，finishing 设为true
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n;
}
}
//旧数组该位置为null，设置已转移标志(节点设为fwd)
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
//该节点已被转移，advance设置true，向前移动，转移前一个节点
else if ((fh = f.hash) == MOVED)
advance = true;
//分情况将旧数组的节点转移到新数组中
else {
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
//链表的处理
if (fh >= 0) {
//计算log(n)位置的值
//0：说明转移到新数组中的位置不变
//1：说明转移到新数组中的位置+n
int runBit = fh & n;
Node<K,V> lastRun = f;
//遍历找到数组中最后连续出现log(n)一样的节点
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
//runBit为0，代表从该节点到最后转移后的位置都不变
if (runBit == 0) {
ln = lastRun;
hn = null;
}
//runBit为1，代表从该节点到最后转移后的位置都+n
else {
hn = lastRun;
ln = null;
}
//遍历链表到lastRun的前一个位置
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
//将转移后位置不变的节点链接到ln
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
//将转移后位置+n的节点链接到hn
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
//位置不变的节点放到新数组对应的位置
setTabAt(nextTab, i, ln);
//位置+n的节点放到新数组+n的位置
setTabAt(nextTab, i + n, hn);
//旧数组中的节点做已转移标志
setTabAt(tab, i, fwd);
//标记需要进入while循环，找到下一个需要处理的位置
advance = true;
}
//红黑树的处理，类似于链表
else if (f instanceof TreeBin) {
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
//从红黑树中找到节点，将所有节点根据扩容后的位置分别链接到lo、hi后面
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(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;
}
}
//长度小于6，将红黑树转换成链表
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
//修改对应位置的数据
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
四、ConcurrentHashMap的get()方法
1、相比于put()方法，get()方法简单很多：
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
//计算hash
int h = spread(key.hashCode());
//找到该位置的元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
//刚好该位置存储的就是要查找的数据，则返回
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
//hash小于0，可能正在扩容和该节点是一棵红黑树，则调用ForwardingNode或者TreeBin相应的方法去查找
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;
}