ConcurrentHashMap并发安全的实现原理~java8

前言

上一篇聊到Java7，今天来聊聊Java8是怎么保证并发安全的。

ConcurrentHashMap in Java8

jdk版本：jdk1.8.0_41
构造器

    /**
     * Creates a new, empty map with the default initial table size (16).
     * 创建一个新的空Map，默认初始hash表大小为16（这里依然是延迟实例化，所以构造器中并没有任何代码）
     */
    public ConcurrentHashMap() {
    }
    
    
    /**
     * Creates a new, empty map with an initial table size based on
     * the given number of elements ({@code initialCapacity}), table
     * density ({@code loadFactor}), and number of concurrently
     * updating threads ({@code concurrencyLevel}).
     *
     * @param initialCapacity the initial capacity. The implementation
     * performs internal sizing to accommodate this many elements,
     * given the specified load factor.
     * @param loadFactor the load factor (table density) for
     * establishing the initial table size
     * @param concurrencyLevel the estimated number of concurrently
     * updating threads. The implementation may use this value as
     * a sizing hint.
     * 并发级别，预估的并发更新线程数量。本实现可能会使用该值作为hash表大小参考。
     * @throws IllegalArgumentException if the initial capacity is
     * negative or the load factor or concurrencyLevel are
     * nonpositive
     */
 	public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        // 初始容量至少为并发线程的个数
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        // 计算hash表的大小=预估容量/负载因子,这么做，是为了降低hash冲突概率
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        // 调整容量为2的幂次
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this.sizeCtl = cap;
    }


    /**
     * Initializes table, using the size recorded in sizeCtl.
     */
    private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                    	// hash表大小
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        // 创建hash表
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        // 计算扩容阈值，等价于n-1/4n，反映的是负载因子0.75，也是利用了大小为2的幂次的便利。
                        sc = n - (n >>> 2);
                    }
                } finally {
                	// 赋值给到阈值成员变量
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

• 默认构造器就不必多说了
• 带并发级别的构造器
  • 并发级别只是作为hash表大小的参考了，不再像Java7那样决定有多少把锁了
  • sizeCtl的巧用。在构造器中，表现的是初始化hash表的大小/容量，而在初始化数组后，就一直是阈值了。这也是为啥要取名为sizeCtl，而不是size，也不是threshold了，因为它包含两层含义。

不管是默认的构造器，还是其他带参构造器，都没有实例化hash表，都是延迟实例化，在put方法中检查并通过上面的initTable来实例化的。

put操作

    /**
     * Maps the specified key to the specified value in this table.
     * Neither the key nor the value can be null.
     *
     * <p>The value can be retrieved by calling the {@code get} method
     * with a key that is equal to the original key.
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @return the previous value associated with {@code key}, or
     *         {@code null} if there was no mapping for {@code key}
     * @throws NullPointerException if the specified key or value is null
     */
    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) {
        if (key == null || value == null) throw new NullPointerException();
        // 将hash值进一步分散。让高位跟低位信息充分保留下来。
        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)
            	// 实例化hash表
                tab = initTable();
            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
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                // 该位置不为空，则锁住该位置所有元素
                // 锁对象f，则为链表的第一个元素
                synchronized (f) {
                	// doubleCheck，避免在取锁后发生改变了
                    if (tabAt(tab, i) == f) {
                    	// hash值有几个特殊的定义，见：D:/InfoTechHome/Tools/java-se-8u41-ri/src.zip!/java/util/concurrent/ConcurrentHashMap.java:594
                    	// -1~-3都表示特定的场景，例如ConcurrentHashMap#TREEBIN=-2，表示为红黑树。而红黑数的第一个元素的hash值为该值。
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                // key是同一个对象，更新value
                                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;
                            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)
                    	// 超过树化阈值8，则转为红黑树。这里会将树的第一个元素的hash设置为-2，进行标识
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        // 通过CAS操作，更新计数器。但注意，是每一个槽都有自己的一个计数器，同样也是通过减小锁粒度，来减小竞争。
        addCount(1L, binCount);
        return null;
    }

上图

小结：

1. Java8中的数据结构为数组+链表/红黑树。
2. 当某一次的put操作，使得某个槽位发生hash冲突的次数大于等于8（即，该链表长度达到了8个），则会将该槽位转为红黑树。
3. 当发生transfer时（例如：数组扩容），检查到某个槽位中的元素已经少于6个了，那么则退化为链表。
4. 每次操作某个槽位时，都以该槽位的第一个元素作为锁对象，通过synchronized关键字上锁。以此来保证put操作的并发安全性。
5. 通过counterCells:CounterCell[]，让计数器也没竞争。
6. 在Java7中的并发级别参数，几乎失去了意义。
7. 在Java8中，不再使用Segment。通过Synchronized+CAS保证并发安全。

总结

相比与Java7的Segment各自管理一张hash表，Java8直接让每一个槽位都有一把锁，并且不需要额外创建锁对象，直接使用槽中的第一个元素作为锁对象。这是多么顺其自然，却又多么巧妙。需要锁的时候，锁对象天然存在，不需要锁的时候，也没有锁对象，用户需要保存的元素就是锁对象！这就是synchronized(f)所代表的含义！而这背后，还是分段锁思想！把锁粒度降低！妙啊！！！