1.1 java.util.ConcurrentHashMap继承结构
ConcurrentHashMap和HashMap的实现有很大的相似性，建议先看HashMap源码，再来理解ConcurrentHashMap。
1.2 java.util.ConcurrentHashMap属性
这里仅展示几个关键的属性
1 // ConcurrentHashMap核心数组
2 transient volatile Node<K,V>[] table; 3 4 // 扩容时才会用的一个临时数组 5 private transient volatile Node<K,V>[] nextTable; 6 7 /** 8 * table初始化和resize控制字段 9 * 负数表示table正在初始化或resize。-1表示正在初始化，-N表示有N-1个线程正在resize操作 10 * 当table为null的时候，保存初始化表的大小以用于创建时使用，或者直接采用默认值0 11 * table初始化之后，保存下一次扩容的的大小，跟HashMap的threshold = loadFactor*capacity作用相同 12 */ 13 private transient volatile int sizeCtl; 14 15 // resize的时候下一个需要处理的元素下标为index=transferIndex-1 16 private transient volatile int transferIndex; 17 18 // 通过CAS无锁更新，ConcurrentHashMap元素总数，但不是准确值 19 // 因为多个线程同时更新会导致部分线程更新失败，失败时会将元素数目变化存储在counterCells中 20 private transient volatile long baseCount; 21 22 // resize或者创建CounterCells时的一个标志位 23 private transient volatile int cellsBusy; 24 25 // 用于存储元素变动 26 private transient volatile CounterCell[] counterCells;
1.3 java.util.ConcurrentHashMap方法
1.3.1 Unsafe.compareAndSwapXXX方法
Unsafe.compareAndSwapXXX方法是sun.misc.Unsafe类中的方法，因为在ConcurrentHashMap中大量使用了这些方法。其声明如下：
public final native boolean compareAndSwapXXX(type1 object, type2 offset, type4 expect, type5 update);
object为待修改的对象，offset为偏移量（数组可以理解为下标），expect为期望值，update为更新值。这个方法执行的逻辑伪代码如下：
1 if (object[offset].value equal expect) {
2 object[offset].value = update;
3 return true; 4 } else { 5 return false 6 }
object[offset].value 等于expect更新value值并返回true，否则不更新并且返回false。之所以不更新是因为多线程执行时有其它线程已经修改该值，expect已经不是最新的值，如果强行修改必然会覆盖之前的修改，造成脏数据。
CAS方法都是native方法，可以保证原子性，并且效率比synchronized高。
1.3.2 hash方法
1 static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash 2 int hash = spread(key.hashCode()); 3 4 static final int spread(int h) { 5 return (h ^ (h >>> 16)) & HASH_BITS; 6 }
上面源码为计算hash算法，h ^ (h >>> 16)在计算hash的时候key.hashCode()的高位也参与运算，这部分跟HashMap计算方法一致，不同的是h ^ (h >>> 16)计算结果“与”上 0x7fffffff，从而保证结果一定为正整数。获得hash之后，通过hash & (n -1)计算下标。
ConcurrentHashMap中的元素节点总结一下有这么几种可能：
(1) null 暂无元素
(2) Node<K, V> 普通节点，可以组成单向链表，hash > 0
(3) TreeBin<K,V> 红黑树节点，TreeBin是对TreeNode的封装，其hash为TREEBIN = -2。
HashMap和ConcurrentHashMap的TreeNode实现并不相同。
在HashMap中TreeNode封装了红黑树所有的操作方法，而ConcurrentHashMap中红黑树操作的方法都封装在TreeBin中，TreeBin相当于一个红黑树容器，容器中的红黑树节点为TreeNode。
HashMap可以直接在tab[i]存入TreeNode，而ConCurrentHashMap只能在tab[i]存入TreeBin。
(4) ForwardingNode<K,V> key和value都为null的一个特殊节点，用于resize操作填充已经完成迁移操作的节点。FrowardingNode的hash在初始化的时候被置成MOVED = -1
在resize过程中当发现tab[i]上是ForwardingNode的时候（通过hash判断）就可知tab[i]已经迁移完了，直接跳过该节点去处理其它节点。
ConcurrentHashMap禁止node的key或value为null或许跟该节点的存在也是有一定关系的。
(5)ReservationNode<K,V>只在compute和computeIfAbsent中使用，其hash为RESERVED = -3
从上面的总结可以看出普通节点hash为正整数是有意义的，hash > 0是判断该节点是否为链表节点（普通节点）的一个重要依据。
1.3.3 get/set/update tab[i] 方法
1 // 获取tab[i]节点
2 static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) { 3 return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE); 4 } 5 6 // compare and swap tab[i]，期望值是c，tab[i].value == c ? tab[i] = v : return false 7 static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i, Node<K,V> c, Node<K,V> v) { 8 return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v); 9 } 10 11 // 设置tab[i] = v 12 static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) { 13 U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v); 14 }
1.3.4 size() 方法
1 public int size() {
2 long n = sumCount(); 3 return ((n < 0L) ? 0 : (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int)n); 4 } 5 6 final long sumCount() { 7 CounterCell[] as = counterCells; CounterCell a; 8 long sum = baseCount; 9 // 除了baseCount以外，部分元素变化存储在counterCells数组中 10 if (as != null) { 11 // 遍历数组累加获得结果 12 for (int i = 0; i < as.length; ++i) { 13 if ((a = as[i]) != null) 14 sum += a.value; 15 } 16 } 17 return sum; 18 }
ConcurrentHashMap中baseCount用于保存tab中元素总数，但是并不准确，因为多线程同时增删改，会导致baseCount修改失败，此时会将元素变动存储于counterCells数组内。
当需要统计当前的size的时候，除了要统计baseCount之外，还需要统计counterCells中的元素变化。
值得一提的是即使如此，统计出来的依旧不是当前tab中元素的准确值，在多线程环境下统计前后并不能stop the world暂停线程操作，因此无法保证准确性。
1.3.5 put/putIfAbsent方法
1 public V put(K key, V value) {
2 // 核心是调用putVal方法 3 return putVal(key, value, false); 4 } 5 6 public V putIfAbsent(K key, V value) { 7 // 如果key存在就不更新value 8 return putVal(key, value, true); 9 } 10 11 /** Implementation for put and putIfAbsent */ 12 final V putVal(K key, V value, boolean onlyIfAbsent) { 13 // key或value 为null都是不允许的，因为Forwarding Node就是key和value都为null，是用作标志位的。 14 if (key == null || value == null) throw new NullPointerException(); 15 // 根据key计算hash值，有了hash就可以计算下标了 16 int hash = spread(key.hashCode()); 17 int binCount = 0; 18 // 可能需要初始化或扩容，因此一次未必能完成插入操作，所以添加上for循环 19 for (Node<K,V>[] tab = table;;) { 20 Node<K,V> f; int n, i, fh; 21 // 表还没有初始化，先初始化，lazily initialized 22 if (tab == null || (n = tab.length) == 0) 23 tab = initTable(); 24 // 根据hash计算应该插入的index，该位置上还没有元素，则直接插入 25 else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { 26 if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null))) 27 break; // no lock when adding to empty bin 28 } 29 // static final int MOVED = -1; // hash for forwarding nodes 30 // 说明f为ForwardingNode，只有扩容的时候才会有ForwardingNode出现在tab中，因此可以断定该tab正在进行扩容 31 else if ((fh = f.hash) == MOVED) 32 // 协助扩容 33 tab = helpTransfer(tab, f); 34 else { 35 V oldVal = null; 36 // 节点上锁，hash值相同的节点组成的链表头结点 37 synchronized (f) { 38 if (tabAt(tab, i) == f) { 39 if (fh >= 0) { // 是链表节点 40 binCount = 1; 41 for (Node<K,V> e = f;; ++binCount) { 42 K ek; 43 // 遍历链表查找是否包含该元素 44 if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { 45 oldVal = e.val; // 保存旧的值用于当做返回值 46 if (!onlyIfAbsent) 47 e.val = value; // 替换旧的值为新值 48 break; 49 } 50 Node<K,V> pred = e; 51 if ((e = e.next) == null) { 52 // 遍历链表，如果一直没找到，则新建一个Node放到链表结尾 53 pred.next = new Node<K,V>(hash, key, value, null); 54 break; 55 } 56 } 57 } 58 else if (f instanceof TreeBin) { // 是红黑树节点 59 Node<K,V> p; 60 binCount = 2; 61 // 去红黑树查找该元素，如果没找到就添加，找到了就返回该节点 62 if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) { 63 // 保存旧的value用于返回 64 oldVal = p.val; 65 if (!onlyIfAbsent) 66 p.val = value; // 替换旧的值 67 } 68 } 69 } 70 } 71 if (binCount != 0) { 72 if (binCount >= TREEIFY_THRESHOLD) 73 // 链表长度超过阈值（默认为8），则需要将链表转为一棵红黑树 74 treeifyBin(tab, i); 75 if (oldVal != null) 76 // 如果只是替换，并未带来节点的增加则直接返回旧的value即可 77 return oldVal; 78 break; 79 } 80 } 81 } 82 // 元素总数加1，并且判断是否需要扩容