ConcurrentHashMap详解,以及各map的相互比较

public V put(K key, V value) {
   return putVal(key, value, false);
}

/** Implementation for put and putIfAbsent */
//onlyIfAbsent的意思是在put一个KV时，如果K已经存在什么也不做则返回null
//如果不存在则put操作后返回V值
final V putVal(K key, V value, boolean onlyIfAbsent) {
   //ConcurrentHashMap中是不能有空K或空V的
   if (key == null || value == null) throw new NullPointerException();
   //hash算法得到hash值
   int hash = spread(key.hashCode());
   int binCount = 0;
   for (Node<K,V>[] tab = table;;) {
       Node<K,V> f; int n, i, fh;
       //如果table是空的，就去初始化，下一个循环就不是空的了
       if (tab == null || (n = tab.length) == 0)
           tab = initTable();
           //如果没有取到值，即取i位的元素是空的，为什么i取值是(n-1)&hash??
           //这是hash的精华所在，在这里可以先思考一下
           //此时直接到KV包装成Node节点放在i位置即可
       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
       }
       //MOVED，定义为-1。标记原table正在执行扩容任务，可以去帮忙(支持多线程扩容)
       else if ((fh = f.hash) == MOVED)
           tab = helpTransfer(tab, f);
       else {
           //这种情况是，在i的位置找到了一个元素，说明此元素的K与之间的某个K的hash结果是一样的
           //
           V oldVal = null;
           synchronized (f) {//同步锁住第一个元素
               if (tabAt(tab, i) == f) {//为了安全起见，再一次判断
                   if (fh >= 0) {//节点的hash值大于0，说明是一个链表结构
                       binCount = 1;//记录链表的元素个数
                       for (Node<K,V> e = f;; ++binCount) {
                           K ek;
                           //判断给定的key是否与取出的key相同，如果是则替换元素
                           if (e.hash == hash &&
                               ((ek = e.key) == key ||
                                (ek != null && key.equals(ek)))) {
                               oldVal = e.val;
                               if (!onlyIfAbsent)
                                   e.val = value;
                               break;//直接跳出，这是一种思想。在编程时可以减少一些if else判断
                           }
                           //否则就是不相等，那就把此元素放在链表的最后一个元素
                           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) {
               //链表的元素大于等于8时，就把链表转换为红黑树
               if (binCount >= TREEIFY_THRESHOLD)
                   treeifyBin(tab, i);
               if (oldVal != null)
                   return oldVal;
               break;
           }
       }
   }
   //新添加一个元素，size加1，可能会触发扩容
   addCount(1L, binCount);
   return null;
}