1.8以前用分段锁实现
static class Segment<K, V> extends ReentrantLock implements Serializable {
final float loadFactor;
Segment(float lf) {
this.loadFactor = lf;
}
}1.8及之后用了Unsafe类的CAS操作和并发扩容机制
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, Serializable {
/**
* 很重要，-1表示正在初始化；
* -N表示有N-1条线程在正在扩容；
* 正数或0代表hash表还没有被初始化，这个数值表示初始化或下一次进行扩容的大小，
* 0代表使用默认的容量16
* 类似于扩容阈值。它的值始终是当前ConcurrentHashMap容量的0.75倍，
* 这与loadfactor是对应的。实际容量>=sizeCtl，则扩容。
*/
private transient volatile int sizeCtl;
transient volatile Node<K,V>[] table;
// 只有扩容是不为null
private transient volatile Node<K,V>[] nextTable;
// 参数、Node、TreeNode和HashMap类似
private static final int MAXIMUM_CAPACITY = 1 << 30;
private static final int DEFAULT_CAPACITY = 16;
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;
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
static class Node<K, V> implements Map.Entry<K, V> {
......
}
static final class TreeNode<K, V> extends Node<K, V> {
......
}
// 封装TreeNode，包含树根，hash为常量TREEBIN（＜0），可以用hash<0判断是链表节点还是树节点，红黑树存放的是TreeBin
static final class TreeBin<K, V> extends Node<K, V> {
TreeNode<K, V> root;
volatile TreeNode<K, V> first;
......
}
// 利用Unsafe类的CAS方法
private static final sun.misc.Unsafe U;
// CAS地获得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);
}
// 将c与tab[i]比较，相同则插入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);
}
// 设置tab[i]的值，仅在上锁区被调用
static final <K, V> void setTabAt(Node<K, V>[] tab, int i, Node<K, V> v) {
U.putObjectVolatile(tab, ((long) i << ASHIFT) + ABASE, v);
}
// 不直接利用key。hashCode()，不允许key == null，HashMap key == null时hash为0
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 不允许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();
// 对应的tab[i]为空，CAS地放入节点
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<K, V>(hash, key, value, null)))
break;
// MOVED是ForwardingNode的哈希值，如果检测到ForwardingNode，帮助扩容
} else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 如果tab[i]不为空，且未检测到ForwardingNode，对tab[i]头结点加锁，下面的过程和HashMap类似
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K, V> e = f;; ++binCount) {
K ek;
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;
}
}
} 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) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 增加计数
addCount(1L, binCount);
return null;
}
// tab的初始化只能由一条线程进行
private final Node<K, V>[] initTable() {
Node<K, V>[] tab;
int sc;
while ((tab = table) == null || tab.length == 0) {
// tab为null，sizeCtl<0，说明其它线程在初始化tab，等待
if ((sc = sizeCtl) < 0)
Thread.yield();
// CAS将sizeCtl改为 -1，成功的话由当前线程初始化tab
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
// sc == 0的话使用默认的容量
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n];
table = tab = nt;
// 将sizeCtl设置为表大小的0.75
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
// 不加锁，只是CAS地获得头结点，再遍历头结点的链表或者树
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
// CAS获得头结点
(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;
}
// tab[i]是红黑树
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
// tab[i]是链表
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
// 这个方法返回值是一个估计值，由于存在并发的插入和删除，因此返回值可能与实际值会有出入。
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
// 线程put()、remove()时如果检测到ForwardingNode会进行扩容
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
// ForwardingNode的hash值是MOVED
super(MOVED, null, null, null);
this.nextTable = tab;
}
Node<K,V> find(int h, Object k) {
......
}
}
// 检查到ForwardingNode则帮助扩容
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) &&
// 利用ForwardingNode中的nextTable
(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;
}
/**
* 实际扩容时，节点为空则置为ForwardingNode，处理下一个节点；
* 节点为ForwardingNode时表示该节点已经处理完毕，处理下一个节点；
* 否则锁住该处的头结点，分成两条链插入nextTab中，类似HashMap，最后置为ForwardingNode
* */
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
......
}
}总结一下，ConcurrentHashMap主要利用了Unsafe类的CAS操作和并发扩容机制，唯一需要加锁的地方是put()、remove()、扩容等操作时对头节点加锁，并发度比分段锁的实现更高。
（1）内部的volatile int sizeCtl表示table是否在初始化、是否在扩容，由线程CAS地去改变；
（2）3个比较重要的CAS方法，get()时利用了CAS，无需加锁；
（3）用内部类ForwardingNode帮助并发扩容，当put()、remove()等操作检测到ForwardingNode时（通过hash值，ForwardingNode的hash为MOVED），线程优先加入扩容的过程，对某个节点转移完毕后置为ForwardingNode，表示该节点转移完毕；
（4）不允许key、value为null。我是这样理解的，get(key) == null时无法判断是key不存在还是value == null，HashMap是单线程的，可以通过if(map.contains(key)) {map.get(key);}来判断，而ConcurrentHashMap则无法判断，除非加锁。
