ConcurrentHashMap源码理解
1.ConcurrentHashMap继承关系
ConcurrentHashMap继承了AbstractMap类，同时实现了ConcurrentMap接口。
2.ConcurrentHashMap构造函数
public ConcurrentHashMap() { } public ConcurrentHashMap(int initialCapacity) { if (initialCapacity < 0) throw new IllegalArgumentException(); int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1)); 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, 1); } 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 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 = 0; for (Node<K,V>[] tab = table;;) { Node<K,V> f; int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); 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) { 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; } 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(); // lost initialization race; just spin 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; sc = n - (n >>> 2); } } 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 >>> 16)) & 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) == 0) 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 == 0) { if ((sc = sizeCtl) < 0) Thread.yield(); // lost initialization race; just spin 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; sc = n - (n >>> 2); } } 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 - 1) & 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 >= 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; } }
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 - 1) < 0 || (a = as[ThreadLocalRandom.getProbe() & m]) == null || !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) { fullAddCount(x, uncontended); return; } if (check <= 1) return; s = sumCount(); } if (check >= 0) { 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 < 0) { if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || (nt = nextTable) == null || transferIndex <= 0) break; if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) transfer(tab, nt); } else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)) transfer(tab, null); s = sumCount(); } } }
_
