之前看过ConcurrentHashMap的分析，感觉也了解的七七八八了。但昨晚接到了面试，让我把所知道的ConcurrentHashMap全部说出来。
然后我结结巴巴，然后应该毫无意外的话就G了，今天下定决心好好分析一下，这个万能的并发包，ConcurrentHashMap
分一下几个方面分析ConcurrentHashMap：
- put方法
- remove方法
- get方法
(一)put方法
1 public V put(K key, V value) { 2 return putVal(key, value, false); 3 }
调用了putVal方法，传入三个参数。第一个为key，第二个为val，第三个为onlyIfAbsent(意思为: 如果为true，当插入的key相同时，不替换val值，默认是为false，替换最新的val值)
putVal方法比较多，我们分两个部分讲：
1 //第一部分 2 final V putVal(K key, V value, boolean onlyIfAbsent) { 3 //对传入的参数进行合法性判断 4 if (key == null || value == null) throw new NullPointerException(); 5 //计算键所对应的 hash 值 6 int hash = spread(key.hashCode()); 7 int binCount = 0; 8 for (Node<K,V>[] tab = table;;) { 9 Node<K,V> f; int n, i, fh; 10 //如果哈希表还未初始化，那么初始化它 11 if (tab == null || (n = tab.length) == 0) 12 tab = initTable(); 13 //根据键的 hash 值找到哈希数组相应的索引位置 14 //如果为空，那么以CAS无锁式向该位置添加一个节点 15 else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { 16 if (casTabAt(tab, i, null, 17 new Node<K,V>(hash, key, value, null))) 18 break; 19 }
我们看到第四行，如果key和val都为null，直接抛出异常，所以不能传入key和val都不能为null。
第二个注意点是 散列这个函数
1 static final int spread(int h) { 2 return (h ^ (h >>> 16)) & HASH_BITS; 3 }
我在HashMap里面有介绍，我就不详细说了，反正很重要。
第三个注意点就是初始化table这个函数initTable
1 private final Node<K,V>[] initTable() { 2 Node<K,V>[] tab; int sc; 3 //如果表为空才进行初始化操作 4 while ((tab = table) == null || tab.length == 0) { 5 //sizeCtl 小于零说明已经有线程正在进行初始化操作 6 //当前线程应该放弃 CPU 的使用 7 if ((sc = sizeCtl) < 0) 8 Thread.yield(); // lost initialization race; just spin 9 //否则说明还未有线程对表进行初始化，那么本线程就来做这个工作 10 else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { 11 //保险起见，再次判断下表是否为空 12 try { 13 if ((tab = table) == null || tab.length == 0) { 14 //sc 大于零说明容量已经初始化了，否则使用默认容量 15 int n = (sc > 0) ? sc : DEFAULT_CAPACITY; 16 @SuppressWarnings("unchecked") 17 //根据容量构建数组 18 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; 19 table = tab = nt; 20 //计算阈值，等效于 n*0.75 21 sc = n - (n >>> 2); 22 } 23 } finally { 24 //设置阈值 25 sizeCtl = sc; 26 } 27 break; 28 } 29 } 30 return tab; 31 }
我们看到第7，8行。如果有线程在初始化，那么那就等待，让出cpu。
初始化只允许一个线程对表进行初始化，如果不巧有其他线程进来了，那么会让其他线程交出 CPU 等待下次系统调度。这样，保证了表同时只会被一个线程初始化。
默认初始化为大小为16，阕值为0.75
我们重新回到putVal这个方法中去。
1 //检测到桶结点是 ForwardingNode 类型，协助扩容 2 else if ((fh = f.hash) == MOVED) 3 tab = helpTransfer(tab, f); 4 //桶结点是普通的结点，锁住该桶头结点并试图在该链表的尾部添加一个节点 5 else { 6 V oldVal = null; 7 synchronized (f) { 8 if (tabAt(tab, i) == f) { 9 //向普通的链表中添加元素，无需赘述 10 if (fh >= 0) { 11 binCount = 1; 12 for (Node<K,V> e = f;; ++binCount) { 13 K ek; 14 if (e.hash == hash &&((ek = e.key) == key ||(ek != null && key.equals(ek)))) { 15 oldVal = e.val; 16 if (!onlyIfAbsent) 17 e.val = value; 18 break; 19 } 20 Node<K,V> pred = e; 21 if ((e = e.next) == null) { 22 pred.next = new Node<K,V>(hash, key,value, null); 23 break; 24 } 25 } 26 } 27 //向红黑树中添加元素，TreeBin 结点的hash值为TREEBIN（-2） 28 else if (f instanceof TreeBin) { 29 Node<K,V> p; 30 binCount = 2; 31 if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) { 32 oldVal = p.val; 33 if (!onlyIfAbsent) 34 p.val = value; 35 } 36 } 37 } 38 } 39 //binCount != 0 说明向链表或者红黑树中添加或修改一个节点成功 40 //binCount == 0 说明 put 操作将一个新节点添加成为某个桶的首节点 41 if (binCount != 0) { 42 //链表深度超过 8 转换为红黑树 43 if (binCount >= TREEIFY_THRESHOLD) 44 treeifyBin(tab, i); 45 //oldVal != null 说明此次操作是修改操作 46 //直接返回旧值即可，无需做下面的扩容边界检查 47 if (oldVal != null) 48 return oldVal; 49 break; 50 } 51 } 52 } 53 //CAS 式更新baseCount，并判断是否需要扩容 54 addCount(1L, binCount); 55 //程序走到这一步说明此次 put 操作是一个添加操作，否则早就 return 返回了 56 return null;
我们看到第三行，如果f的hash是MOVED，那么就帮助他扩容(说明至少有一个线程在扩容)
这个方法说实话我看的不太懂，我就在网上查了点资料：
首先，每个线程进来会先领取自己的任务区间，然后开始 --i 来遍历自己的任务区间，对每个桶进行处理。如果遇到桶的头结点是空的，那么使用 ForwardingNode 标识该桶已经被处理完成了。如果遇到已经处理完成的桶，直接跳过进行下一个桶的处理。如果是正常的桶，对桶首节点加锁，正常的迁移即可，迁移结束后依然会将原表的该位置标识位已经处理。
当 i < 0，说明本线程处理速度够快的，整张表的最后一部分已经被它处理完了，现在需要看看是否还有其他线程在自己的区间段还在迁移中。
putVal后面的代码就比较清楚了。如果是链表，就找到尾节点，插入即可。如果是红黑树，童谣插入即可。
至此，对于 put 方法的源码分析已经完全结束了，感觉真的很复杂。至此我感觉我都没有完全理解每一行代码是什么意思。
(二)remove方法
1 public V remove(Object key) { 2 return replaceNode(key, null, null); 3 }
三个参数，第一个为key，第二个为val，删除直接置为null，让gc来回收。第三个是Object cv，含义还不是很清楚。先继续看吧
我们还是分为两部分：
1 //第一部分 2 final V replaceNode(Object key, V value, Object cv) { 3 //先找到key的位置 hash散列 4 int hash = spread(key.hashCode()); 5 for (Node<K,V>[] tab = table;;) { 6 Node<K,V> f; int n, i, fh; 7 //如果表为空，直接返回null 8 if (tab == null || (n = tab.length) == 0 || 9 (f = tabAt(tab, i = (n - 1) & hash)) == null) 10 break; 11 //如果有在扩容的线程，帮助他扩容 12 else if ((fh = f.hash) == MOVED) 13 tab = helpTransfer(tab, f);
首先遍历整张表的桶结点，如果表还未初始化或者无法根据参数的 hash 值定位到桶结点，那么将返回 null。
如果定位到的桶结点类型是 ForwardingNode 结点，调用 helpTransfer 协助扩容。
1 else { 2 V oldVal = null; 3 boolean validated = false; 4 synchronized (f) { 5 if (tabAt(tab, i) == f) { 6 if (fh >= 0) { 7 validated = true; 8 for (Node<K,V> e = f, pred = null;;) { 9 K ek; 10 if (e.hash == hash && 11 ((ek = e.key) == key || 12 (ek != null && key.equals(ek)))) { 13 V ev = e.val; 14 if (cv == null || cv == ev || 15 (ev != null && cv.equals(ev))) { 16 oldVal = ev; 17 if (value != null) 18 e.val = value; 19 else if (pred != null) 20 pred.next = e.next; 21 else 22 setTabAt(tab, i, e.next); 23 } 24 break; 25 } 26 pred = e; 27 if ((e = e.next) == null) 28 break; 29 } 30 } 31 else if (f instanceof TreeBin) { 32 validated = true; 33 TreeBin<K,V> t = (TreeBin<K,V>)f; 34 TreeNode<K,V> r, p; 35 if ((r = t.root) != null && 36 (p = r.findTreeNode(hash, key, null)) != null) { 37 V pv = p.val; 38 if (cv == null || cv == pv || 39 (pv != null && cv.equals(pv))) { 40 oldVal = pv; 41 if (value != null) 42 p.val = value; 43 else if (t.removeTreeNode(p)) 44 setTabAt(tab, i, untreeify(t.first)); 45 } 46 } 47 } 48 } 49 } 50 if (validated) { 51 if (oldVal != null) { 52 if (value == null) 53 addCount(-1L, -1); 54 return oldVal; 55 } 56 break; 57 } 58 }
代码很多，但我觉得思路不难。就是找到那个桶以后，直接加锁。判断是链表还是树，然后删除即可。
(三)get方法
1 public V get(Object key) { 2 Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek; 3 int h = spread(key.hashCode()); 4 if ((tab = table) != null && (n = tab.length) > 0 && 5 (e = tabAt(tab, (n - 1) & h)) != null) { 6 if ((eh = e.hash) == h) { 7 if ((ek = e.key) == key || (ek != null && key.equals(ek))) 8 return e.val; 9 } 10 else if (eh < 0) 11 return (p = e.find(h, key)) != null ? p.val : null; 12 while ((e = e.next) != null) { 13 if (e.hash == h && 14 ((ek = e.key) == key || (ek != null && key.equals(ek)))) 15 return e.val; 16 } 17 } 18 return null; 19 }
和HashMap的get方法大同小异。没有涉及到并发操作。直接取到key的hash值，如果是第一个节点，直接返回。否则while循环查找