ConcurrentHashMap之put源码阅读

淡淡的烟草味﹌ 2022-10-04 14:55 193阅读 0赞

`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;
        }