Java集合 —— ConcurrentHashMap源码笔记

简介

HashMap是线程不安全的,所以 Java 还提供了 ConcurrentHashMap 类来解决高并发下的安全问题。

Java8 中,ConcurrentHashMap 相对于 Java7 来说, 它是通过 CAS 操作和 synchronized 来实现线程安全的, 而 Java7 是使用分段锁来实现线程安全的,并且Java7是对数组分段同步,而 Java8 是对数组元素同步。

这里大致看下的它的源码,ConcurrentHashMap 相对于 HashMap 来说,因为它处理的并发的情况,所以源码会复杂不少,这里做个大致了解与 HashMap 做个对比。

依然从 put 开始了解 ConcurrentHashMap 是如何实现线程安全的。

源码分析 Java8

put 方法

    public V put(K key, V value) {
        return putVal(key, value, false);
    }
    
    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        //这里可以直接发现一个和 HashMap 不同的地方, ConcurrentHashMap 不支持含 null 的键值对
        if (key == null || value == null) throw new NullPointerException();
        //计算哈希值
        int hash = spread(key.hashCode());
        //这个值将用来记录链表或者红黑树长度
        int binCount = 0;
        //此处开始自旋
        for (Node[] tab = table;;) {
            Node f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                //如果数组不存在或者长度为 0,则初始化数组
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                //如果计算出来的位置在数组中还没有存放对象,那么通过 CAS 来放入
                if (casTabAt(tab, i, null,
                             new Node(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;
                //使用 synchronized 同步该位置下对应的数组里的对象
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                        //如果存在链表
                            binCount = 1;
                            //遍历链表
                            for (Node e = f;; ++binCount) {
                                //接来下的逻辑和 HashMap 一样,在链表尾部插入新对象
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {
                        //如果当前块里是红黑树
                            Node p;
                            binCount = 2;
                            //此处遍历红黑树
                            if ((p = ((TreeBin)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                //如果 key 相同, 那么根据 onlyIfAbsent 判断是否需要替换                           
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                        else if (f instanceof ReservationNode)
                            throw new IllegalStateException("Recursive update");
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        // 链表节点大于8 转成红黑树
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        //扩容的逻辑也在这里面
        addCount(1L, binCount);
        return null;
    }

ConcurrentHashMap 的 put 方法,首先自旋,如果存放对象的块中为 null 时,将通过 CAS 来放入新键值对,如果已经存在对象的话,则使用 synchronized 给插入操作上锁。

如果发现正在扩容,那么将会利用并发的特性,来帮助扩容。

补上初始化数组的方法 initTable

initTable 方法

    /**
     * Initializes table, using the size recorded in sizeCtl.
     */
    private final Node[] initTable() {
        Node[] tab; int sc;
        //不断循环直到数组建立
        while ((tab = table) == null || tab.length == 0) {
            if ((sc = sizeCtl) < 0)
                //如果 sizeCtl 小于 0,则说明有其他地方先初始化数组,所以放弃执行权
                Thread.yield(); // lost initialization race; just spin
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            //不然就通过 CAS 来修改 sizeCtl 值为 -1 ,告诉其它线程数组正在初始化
                try {
                    //接下来就是创建一个数组
                    if ((tab = table) == null || tab.length == 0) {
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node[] nt = (Node[])new Node[n];
                        table = tab = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    //创建完数组后就将 sizeCtl 修改
                    sizeCtl = sc;
                }
                break;
            }
        }
        //返回创建好的数组
        return tab;
    }

可以看出 ConcurrentHashMap 初始化数组的核心是 sizeCtl 这个值,这个值是 volatile 修饰的,保证了它的可见性,通过判断这个值是不是小于 0,来决定是否需要执行数组的初始化。

最后

从这两段源码可以看出 ConcurrentHashMap 是怎么样实现一个线程安全的 HashMap 了。

这里引出一下 HashTable 为什么被弃用的问题。

HashTable 与 HashMap 的不同

  • 不支持 null 键值对,HashMap 可以。
  • 线程安全,是对修改过程同步实现的,这样效率会很低。而 HashMap 不是线程安全。
  • 初始容量是 11, 扩容是 2 * oldCap + 1, HashMap 为 16,2 * oldCap。
  • 初始容量即扩容大小不一样,所以计算 index 的值方法也不一样。

为什么弃用 HashTable

原因主要出在上面第二点,它的修改是对整个方法同步实现的,效率会低非常多,同时它与 HashMap 还是有许多不同的地方, ConcurrentHashMap 在容量以及扩容规则等都延续了 HashMap。

你可能感兴趣的:(Java集合 —— ConcurrentHashMap源码笔记)