ConcurrentHashMap源码分析之put、putVal

说明

ConcurrentHashMap（以下简称CHM）的put直接调用putVal。putVal的实现有如下几个原则：

1. CHM table（即Node<K,V>数组）的长度往往没有key的hash值大，为了尽可能分散数据，应当让key的hash值参与到index的计算中，所以将hash值的右移16位后和原值异或。
2. 写入时用synchronized加锁，不过为了提高效率，采用双检锁
3. 用的锁是table中的元素，链头或TreeBin
4. 解决Hash冲突的方法有两种：冲突少用链表；冲突多用红黑树。阈值是8
5. 如果有冲突，就检查是否需要扩容

源码

final V putVal(K key, V value, boolean onlyIfAbsent) {
 if (key == null || value == null) throw new NullPointerException();
 // key的hash值右移16位与原值“异或”，以扩大高16位对计算index的影响
 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();
     // (n-1)&hash体现了n为2的幂优势。‘&’可以消除非法hash的影响，跟spread里的“&0x7fff ffff”一起构成了双保险。
     else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
 	 // 目标位置未设置，则用CAS设置
     if (casTabAt(tab, i, null,
           new Node<K,V>(hash, key, value, null)))
         break;                   // no lock when adding to empty bin
     }
     // f是目标位置已有的Node。其hash值标为MOVED（-1），表示table已经扩容，且目标位置的Node已经复制到了nextTable。而且此时f的类型应该是：ForwardingNode
     else if ((fh = f.hash) == MOVED)
         // 直接将当前线程加入到扩容工作中。CHM的这个设计非常主动。
         tab = helpTransfer(tab, f);
     else {
         V oldVal = null;
         // 简单锁，以目标为指导的bin为锁
         synchronized (f) {
         	 // 判断一下是否被别的线程改掉了。典型的双检锁
             if (tabAt(tab, i) == f) {
                 // MOVED=-1，TREEBIN=-2，RESERVED=-3
                 if (fh >= 0) {
                     binCount = 1;
                     // 拉链循环，直到找到已有的Node（key相同），或链尾
                     for (Node<K,V> e = f;; ++binCount) {
                         K ek;
                         // 如果就是当前Node，直接设置
                         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;
                     // 树化时，table中的bin不是树根，而是指向树根，所以计为2。已经树化了，binCount也就不再增加。只是作为addCount的check参数，检查是否需要扩容
                     binCount = 2;
                     if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                    value)) != null) {
                         // oldVal不空，说明是覆盖
                         oldVal = p.val;
                         if (!onlyIfAbsent)
                             p.val = value;
                     }
                 }
             }
         }
         if (binCount != 0) {
             // 当拉链长度超过8时，树化该链
             if (binCount >= TREEIFY_THRESHOLD)
                 treeifyBin(tab, i);
             // 如果是覆盖旧值，则无需扩容
             if (oldVal != null)
                 return oldVal;
             break;
         }
     }
 }
 // 对于新增Node的情况（原处无值），binCount>0时执行扩容
 addCount(1L, binCount);
 return null;
}