ConcurrentHashMap之put源码阅读

ConcurrentHashMap之所以是安全的map就是因为它在put的时候进行了锁处理，下面是整个put的过程，基本上都写了注释，看完之后可以帮助你更好的理解它的原理。

关于ConcurrentHashMap的其它源码，比如扩容、计数器等，看看以后是否有时间吧。

 final V putVal(K key, V value, boolean onlyIfAbsent) {
      // 不允许null值和nullkey
        if (key == null || value == null) throw new NullPointerException();
        /*
         * 使用key计算出hash值
         *  (h ^ (h >>> 16)) & HASH_BITS  (HASH_BITS = 0x7fffffff)
         */
        int hash = spread(key.hashCode());
        int binCount = 0;
        // 死循环，直到 break 跳出
        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）去判断当位置是否已经有值了
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                /*
                 * 如果没有值使用乐观锁的方式添加进去
                 *
                 * 底层是调用了native的方法：compareAndSwapObject(obj,i,expect,update)
                 * 如果 obj的 i位置的值等于 expect，那么就更新为 update
                 *
                 * 因为这个地方是把数据添加到 null 位置，所以不需要加锁（我们可以看到 expect为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;
                // 如果添加的key已经存在，就锁住进行修改
                synchronized (f) {
                    // 再次判断下当前的值是否被改动过
                    if (tabAt(tab, i) == f) {
                        // 当数据量很大的时候可能得出的hashcode为负数
                        if (fh >= 0) {
                            binCount = 1;
                            // 循环当前链表
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                // 如果当前节点key的hashcode和新增key的相同，并且key值相同，则覆盖
                                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;
                                // 如果已经循环到最后一个节点还是没有找到相同的key，就添加到链表尾
                                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;
                            /*
                             * putTreeVal: 添加或者找到该节点，如果是添加就返回 null
                             *
                             * 这个方法的意思是如果找到了该节点，就替换它的 value
                             */
                            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;
    }