1.ConcurrentHashMap继承关系
ConcurrentHashMap继承了AbstractMap类，同时实现了ConcurrentMap接口。
2.ConcurrentHashMap构造函数
public ConcurrentHashMap() {
}
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < )
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> )) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> ) + ));
this.sizeCtl = cap;
}
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, );
}
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < || concurrencyLevel <= )
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
ConcurrentHashMap()：这个没什么好说的，无参构造函数一切都是使用默认值。
ConcurrentHashMap(int)：int指定了实例可以承载的数据容量，如果容量大于允许最大容量的一半，直接初始化为最大容量。否则的话，会先计算数组长度(为容量的1.5倍加1)，然后再同hashmap一样，计算大于数组长度的最小的2的幂次方作为数组长度。
ConcurrentHashMap(int,float)：内部实际调用了ConcurrentHashMap(int,float,int)，最后一个参数填1。
ConcurrentHashMap(int,float,int)：参数依次指定了实例可以承载的数据容量initialCapacity，负载因子loadFactor，同步等级concurrencyLevel。初始容量不能小于同步等级，如果小于，则令其等于同步等级的数值。然后用初始容量除以负载因子，获取数组大小，再求出最小的2的幂次方。
ConcurrentHashMap(Map)：参数使用默认的参数，同时调用putAll(Map)方法。
3.ConcurrentHashMap添加元素
3.1添加元素核心类
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
int binCount = ;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == )
tab = initTable();
else if ((f = tabAt(tab, i = (n - ) & 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) {
if (fh >= ) {
binCount = ;
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 = ;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != ) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == ) {
if ((sc = sizeCtl) < )
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -)) {
try {
if ((tab = table) == null || tab.length == ) {
int n = (sc > ) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> );
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
源码解析：
1.在concurrentHashMap中要求key和value都不能为空，否则会抛出NPE。
if (key == null || value == null) throw new NullPointerException();
2.计算key新的hash值
int hash = spread(key.hashCode());
static final int spread(int h) {
return (h ^ (h >>> )) & HASH_BITS;
}
3.循环实例中存放元素的table，如果table没有初始化，则进行初始化
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == )
tab = initTable();
首先注意这里的for，它的里面是一个无限循环，也就是说会一直循环下去，直到遇见break。
初始化table，这里使用了乐观锁U.compareAndSwapInt()方法，有且只有一个线程t能够将SIZECTL设置为-1，此时其他的所有线程都会进入Thread.yield()让出cpu进行循环等待。当t线程执行完最后一行后，对sizeCtl进行了赋值，此时其他的线程会判断tab!=null，且tab.length!=0，因此也会跳出循环，返回已经被t线程创建好的table。
线程t通过乐观锁，执行初始化table的逻辑，如果实例没有被赋予初始化容量，则使用默认的初始化容量16来作为数组长度创建数组。然后执行sc=n-(n>>>2)，实际令sc=0.75sc，求出了在默认0.75f的负载因子下可存储数据数量。最后返回创建的数组node[16]。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == ) {
if ((sc = sizeCtl) < )
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -)) {
try {
if ((tab = table) == null || tab.length == ) {
int n = (sc > ) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> );
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
4.利用tabAt()方法获取数组上对应hash值位置上的值，如果为空，则调用casTabAt方法将新待添加的元素放置在该位置上。
而在tabAt()方法内部，是调用了getObjectVolatile(Node[], int)，直接从内存中读取数组中元素的准确值。
同时在casTabAt(Node[], int, Node, Node)中，利用乐观锁进行对空赋值。
else if ((f = tabAt(tab, i = (n - ) & hash)) == null) {
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
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);
}
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);
}
5.如果数组位置上已有值，判断这个值的hash值是否等于-1，等于则调用helpTransfer(node[],int)方法。
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
6.以上条件都判断后，确定数组元素的正常，通过synchronized获取锁，拿到锁之后，首先判断元素是否已经被其他线程改变了，如果改变了，重新执行for循环，获取新的元素，没有改变则判断元素是链表(hash值大于0)还是红黑树(instanceof TreeBin)。
(1)链表：从首节点开始遍历，如果找到有相等的key(hash值相等，key也相等)，则进行value值的替换，否则创建一个新的节点，添加在链表最后位置。
(2)红黑树：putTreeVal(int, K, V);
对元素处理完成后，释放锁，判断当前链表上添加的元素是否大于等于8，如果是，则将当前结构转为树结构。如果是替换了已有的节点，则返回旧值，执行到此结束。
else {
V oldVal = null;
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= ) {
binCount = ;
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 = ;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != ) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
7.如果是新添加的节点，需要执行最后一步。addCount(long,int)方法
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
if (as == null || (m = as.length - ) < ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= )
return;
s = sumCount();
}
if (check >= ) {
Node<K,V>[] tab, nt; int n, sc;
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < ) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= )
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + ))
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + ))
transfer(tab, null);
s = sumCount();
}
}
}
_