Jdk1.6 JUC源码解析(25)-ConcurrentHashMap

Jdk1.6 JUC源码解析(25)-ConcurrentHashMap

作者:大飞

 

功能简介:

  • ConcurrentHashMap是一种线程安全的HashMap。相对于HashTable和Collections.synchronizedMap(),ConcurrentHashMap具有更好的性能和伸缩性,是由于其使用了分段锁的策略,将内部数据分为多个段,每个段单独加锁,而不是整个HashMap加锁,这样能减少很多不必要的锁争用。

 
源码分析:

  • ConcurrentHashMap实现了ConcurrentMap接口,先简单了解下这个接口:

 

public interface ConcurrentMap<K, V> extends Map<K, V> {
    /**
     * 如果map中已经存在给定的key,返回map中key对应的value;
     * 如果不存在给定的key,插入给定的key和value。
     * 这个是一个原子操作,逻辑相当于:
     *   if (!map.containsKey(key))
     *       return map.put(key, value);
     *   else
     *       return map.get(key);
     */
    V putIfAbsent(K key, V value);
    /**
     * 如果map中存在给定的key,并且map中对应的value也等于给定的value,
     * 那么删除这个key和value。
     * 这是一个原子操作,逻辑相当于:
     *   if (map.containsKey(key) && map.get(key).equals(value)) {
     *       map.remove(key);
     *       return true;
     *   } else return false;
     */
    boolean remove(Object key, Object value);
    /**
     * 如果map中存在给定的key,并且map中对应的value也等于给定的oldValue,
     * 那么将这个key对应的value替换成newValue。
     * 这是一个原子操作,逻辑相当于:
     *   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
     *       map.put(key, newValue);
     *       return true;
     *   } else return false;
     */
    boolean replace(K key, V oldValue, V newValue);
    /**
     * 如果map中已经存在给定的key, 
     * 那么将这个key对应的value替换成给定的value。
     * 这是一个原子操作,逻辑相当于:
     *   if (map.containsKey(key)) {
     *       return map.put(key, value);
     *   } else return null;
     */
    V replace(K key, V value);
}

       ConcurrentMap扩展了Map接口,定义了上面4个原子操作方法。

 

 

  • 接下来看下ConcurrentHashMap的内部结构:

 

    /**
     * segment数组, 每一个segment都是一个hash table。
     */
    final Segment<K,V>[] segments;

 

 

 

       重点看下segment的实现吧,首先看数据结构:

    static final class Segment<K,V> extends ReentrantLock implements Serializable {
        private static final long serialVersionUID = 2249069246763182397L;
        /**
         * 记录segment(哈希表)中的元素数量。
         * 另一个重要角色就是其他操作会利用count的volatile读写来保证可见性,避免使用锁。
         */
        transient volatile int count;
        /**
         * 统计跟踪修改,用来保证一些批量操作的一致性。
         * 比如统计所有segment元素个数时,如果统计过程发现modCount变化
         * 那么需要重试。
         */
        transient int modCount;
        /**
         * 当哈希表的容量超过了这个阀值,表会扩容,里面的元素会重新散列。
         * 这个值一般是:capacity * loadFactor
         */
        transient int threshold;
        /**
         * 存放数组的哈希表。
         */
        transient volatile HashEntry<K,V>[] table;
        /**
         * 哈希表的加载因子。
         * @serial
         */
        final float loadFactor;

   

       再看下segment的构造方法:

        Segment(int initialCapacity, float lf) {
            loadFactor = lf;
            setTable(HashEntry.<K,V>newArray(initialCapacity));
        }
        
        void setTable(HashEntry<K,V>[] newTable) {
            threshold = (int)(newTable.length * loadFactor);
            table = newTable;
        }
    static final class HashEntry<K,V> {
        final K key;
        final int hash;
        volatile V value;
        final HashEntry<K,V> next;
        HashEntry(K key, int hash, HashEntry<K,V> next, V value) {
            this.key = key;
            this.hash = hash;
            this.next = next;
            this.value = value;
        }
	    @SuppressWarnings("unchecked")
	    static final <K,V> HashEntry<K,V>[] newArray(int i) {
	        return new HashEntry[i];
	    }
    }

 

 

       可见,构造segment时需要一个初始容量和一个加载因子,segment内部会创建一个长度为初始容量大小的HashEntry数组。          
如果对哈希表数据结构比较熟悉的话会知道,哈希表内部一般会有初始容量ic和加载因子lf,当哈希表中的元素数量达到(ic * lf)的时候,就会触发哈希表进行rehash。这有什么影响呢?假设哈希表使用链表法来解决哈希冲突,那么如果加载因子太大,会导致哈希表中每个桶里面的链表平均长度过长,这样会影响查询性能;但如果加载因子过小,又会浪费太多内存空间。所以也是一种时间和空间的权衡,需要按实际情况来选择合适的加载因子。          最后看下ConcurrentHashMap的构造方法:

    /* ---------------- Constants -------------- */
    //默认segment中hashTable长度。
    static final int DEFAULT_INITIAL_CAPACITY = 16;
    //默认加载因子。
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //默认table的并发级别,其实就是segment数组长度。
    static final int DEFAULT_CONCURRENCY_LEVEL = 16;
    //table的最大容量。
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //允许的最大的segment数组长度。
    static final int MAX_SEGMENTS = 1 << 16; 
    /**
     * 在size和containsValue方法中,加锁之前的尝试操作次数。
     */
    static final int RETRIES_BEFORE_LOCK = 2;
    /* ---------------- Fields -------------- */
    /**
     * 计算segment下标的掩码。一个key的hash code高位(由segmentShift确定)用来确定segment下标。
     */
    final int segmentMask;
    /**
     * segment下标的位移值。
     */
    final int segmentShift;

    public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (concurrencyLevel > MAX_SEGMENTS)
            concurrencyLevel = MAX_SEGMENTS; //concurrencyLevel不能超过最大值
        // Find power-of-two sizes best matching arguments
        int sshift = 0;
        int ssize = 1;
        while (ssize < concurrencyLevel) { 
            ++sshift;
            ssize <<= 1; //ssize最后是比concurrencyLevel大的最小的2的幂。
        }
        /*
         * 假设传入的concurrencyLevel是50,
         * 那么ssize就是64,sshift就是6,segmentMask就是 00000000 00000000 00000000 00111111*/
        segmentShift = 32 - sshift;
        segmentMask = ssize - 1; 
        this.segments = Segment.newArray(ssize);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        int c = initialCapacity / ssize;
        if (c * ssize < initialCapacity)
            ++c;
        int cap = 1;
        while (cap < c)
            cap <<= 1; //cap其实就是比总体容量平均分到每个segment的数量大的最小的2的幂...有点绕,
        for (int i = 0; i < this.segments.length; ++i)
            this.segments[i] = new Segment<K,V>(cap, loadFactor); //把segment都初始化一下。
    }

    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
    }

    public ConcurrentHashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
    }

       可以看到构造方法中计算了几个重要的数:segment掩码、segment位移值、segment数组长度和segment内部哈希表容量,注意后两个都是2的幂,想到了什么? a & (b – 1)吧哈哈。          这里做个小结:ConcurrentMap内部包含一个segment的数组;而segment本身又是一个哈希表,并且自带锁;内部哈希表使用链表法解决哈希冲突,每个数组元素是一个单链表。  

  • 现在从插入和获取操作切入,来理解源码。先看下插入操作:
    public V put(K key, V value) {
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key.hashCode());
        return segmentFor(hash).put(key, hash, value, false);
    }

       注意到,put过程中,首先要根据key的hashCode,再次算一个hash值出来;其次是要根据这个hash值来确定一个segment,然后把key-value存到这个segment里面。

    /**
     * Applies a supplemental hash function to a given hashCode, which
     * defends against poor quality hash functions.  This is critical
     * because ConcurrentHashMap uses power-of-two length hash tables,
     * that otherwise encounter collisions for hashCodes that do not
     * differ in lower or upper bits.
     */
    private static int hash(int h) {
        // Spread bits to regularize both segment and index locations,
        // using variant of single-word Wang/Jenkins hash.
        h += (h <<  15) ^ 0xffffcd7d;
        h ^= (h >>> 10);
        h += (h <<   3);
        h ^= (h >>>  6);
        h += (h <<   2) + (h << 14);
        return h ^ (h >>> 16);
    }
    /**
     * Returns the segment that should be used for key with given hash
     * @param hash the hash code for the key
     * @return the segment
     */
    final Segment<K,V> segmentFor(int hash) {
        return segments[(hash >>> segmentShift) & segmentMask];
    }

       首先看下这个hash算法,它相当于在key本身的hashCode上做了加强,再次hash一次,使得hash值更加散列。这样做的原因是因为ConcurrentHashMap中哈希表的长度都是2的幂,会增加一些冲突几率,比如两个hashCode高位不同但低位相同,对哈希表长度取模时正好忽略了这些高位,造成冲突。这里是采用了Wang/Jenkins哈希算法的一个变种,更多相关信息可以google之。

       接下来是确定segment的步骤,在上面ConcurrentHashMap的构造方法中我们看到,sshift和segmentMask有个关系,如果sshift=6,那么segmentMask后面就有6个为1的bit。 其实这里是用hash值除去低sshift位剩余的高位,来确定segment的下标。          定位到了segment,继续看segment中怎么put元素的:

        V put(K key, int hash, V value, boolean onlyIfAbsent) {
            lock();// 加锁
            try {
                int c = count;
                if (c++ > threshold) // ensure capacity
                    rehash(); // 如果添加一个元素后,超过扩容阀值,那么进行rehash。
                HashEntry<K,V>[] tab = table;
                int index = hash & (tab.length - 1); // 对hash取模算出key对应的哈希表的桶的下标。
                HashEntry<K,V> first = tab[index]; // 找出桶的第一个节点
                HashEntry<K,V> e = first;
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next; // 遍历一下桶里的单链表,看看有没有相同的。
                V oldValue;
                if (e != null) {
                    // 如果找到了相同的,记录旧值
                    oldValue = e.value;
                    if (!onlyIfAbsent) // 并且有覆盖标识
                        e.value = value; // 那么覆盖这个值
                }
                else {
                    // 如果没找到相同的。
                    oldValue = null;
                    ++modCount; // 因为会改变哈希表元素个数,所以modCount累加。
                    // 将元素设置为桶内新的第一个节点。
                    tab[index] = new HashEntry<K,V>(key, hash, first, value); 
                    count = c; // 注意这里做了一个volatile写。
                }
                return oldValue; // 返回旧值。
            } finally {
                unlock(); // 解锁。
            }
        }

       代码也比较容易理解,注意有rehash的情况,看下rehash方法:

        void rehash() {
            HashEntry<K,V>[] oldTable = table;
            int oldCapacity = oldTable.length;
            if (oldCapacity >= MAXIMUM_CAPACITY)
                return; //不能超过最大容量。
            /*
             * 将哈希表中所有桶里的节点重新分配到新哈希表中。
             * 由于使用的容量是2的幂,所有一部分节点会分配到新哈希表中相同 
             * 下标的桶里,这样我们就可以重用这些节点,而无需重新创建。
             * 按照统计数据,在默认的加载因子下,大约只有六分之一的节点在 
             * 哈希表扩容的时候需要拷贝(重新创建对象)。
             */
            HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1);
            threshold = (int)(newTable.length * loadFactor);
            int sizeMask = newTable.length - 1;
            for (int i = 0; i < oldCapacity ; i++) {
                HashEntry<K,V> e = oldTable[i];
                if (e != null) {
                    HashEntry<K,V> next = e.next;
                    int idx = e.hash & sizeMask;
                    if (next == null)
                        newTable[idx] = e; // 链表上唯一的节点,直接复制到新table。
                    else {
                        // 重用从尾部往前能定位到新table中同一个桶的,最长的连续节点。
                        HashEntry<K,V> lastRun = e;
                        int lastIdx = idx;
                        for (HashEntry<K,V> last = next;
                             last != null;
                             last = last.next) {
                            int k = last.hash & sizeMask;
                            if (k != lastIdx) {
                                lastIdx = k;
                                lastRun = last;
                            }
                        }
                        newTable[lastIdx] = lastRun;
                        // 其他的节点就copy过去了。
                        for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                            int k = p.hash & sizeMask;
                            HashEntry<K,V> n = newTable[k];
                            newTable[k] = new HashEntry<K,V>(p.key, p.hash,
                                                             n, p.value);
                        }
                    }
                }
            }
            table = newTable;
        }

   

       put的实现看完了,继续看下从ConcurrentHashMap中get的实现:

    public V get(Object key) {
        int hash = hash(key.hashCode());
        return segmentFor(hash).get(key, hash);
    }

       流程还是先算hash值,然后确定到segment,然后调用segment的get方法:

        V get(Object key, int hash) {
            if (count != 0) { // 这里做一个volatile读
                HashEntry<K,V> e = getFirst(hash); //获取相应桶的第一个节点。
                while (e != null) {
                    if (e.hash == hash && key.equals(e.key)) {
                        V v = e.value;
                        if (v != null)
                            return v; //如果是相同的key,返回value。
                        return readValueUnderLock(e); // recheck
                    }
                    e = e.next;
                }
            }
            return null;
        }
        HashEntry<K,V> getFirst(int hash) {
            HashEntry<K,V>[] tab = table;
            return tab[hash & (tab.length - 1)];
        }
        /**
         * 加锁读value。如果value为nul的情况下调用这个方法。
         * 只有在编译器将HashEntry的初始化和其赋值给table的指令重排才会 
         * 出现这种情况,这在内存模型下是合法的,但从没发生过。
         */
        V readValueUnderLock(HashEntry<K,V> e) {
            lock();
            try {
                return e.value;
            } finally {
                unlock();
            }
        }

 

 

  • 理解了put和get过程,其他方法也很好理解了:

 

        boolean containsKey(Object key, int hash) {
            if (count != 0) { // read-volatile
                HashEntry<K,V> e = getFirst(hash);
                while (e != null) {
                    if (e.hash == hash && key.equals(e.key))
                        return true;
                    e = e.next;
                }
            }
            return false;
        }

 

        V remove(Object key, int hash, Object value) {
            lock();
            try {
                int c = count - 1;
                HashEntry<K,V>[] tab = table;
                int index = hash & (tab.length - 1);
                HashEntry<K,V> first = tab[index];
                HashEntry<K,V> e = first;
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next;
                V oldValue = null;
                if (e != null) {
                    V v = e.value;
                    if (value == null || value.equals(v)) {
                        oldValue = v;
                        // All entries following removed node can stay
                        // in list, but all preceding ones need to be
                        // cloned.
                        ++modCount;
                        HashEntry<K,V> newFirst = e.next;
                        for (HashEntry<K,V> p = first; p != e; p = p.next)
                            newFirst = new HashEntry<K,V>(p.key, p.hash,
                                                          newFirst, p.value);
                        tab[index] = newFirst;
                        count = c; // write-volatile
                    }
                }
                return oldValue;
            } finally {
                unlock();
            }
        }

       我们会发现所有的写操作最后都会写一下count,而且所有的读操作最前面都会读一下count,由于count是volatile修饰的,所以这样相当于加了内存屏障(volatile写和后面的volatile读不能重排),保证了读操作能够看到最新的写的变化。

       以上理解有偏差,感谢@不待人亲指正。

       仔细看源码注释发现:

       All (synchronized) write operations should write to the “count” field after structurally changing any bin.

       也就是说只有bin(HashEntry链)的结构变化之后才会写count(覆盖的情况不会写count)。

       所以这里纠正一下:所有改变bin结构的写操作都会写一下count,可以保证HashEntry的可见性(因为无论是添加还是删除,bin起始的HashEntry都会发生变化,由于HashEntry的next域是不变的,所以删除时需要将目标HashEntry之前的Entry都拷贝一下)。

       而覆盖旧值的情况下不会写count,因为HashEntry的value本身也是volatile的,可以保证自身的可见性。

 

  • 我们上面还看到了有一个RETRIES_BEFORE_LOCK值,看看这个值起什么作用:
    public int size() {
        final Segment<K,V>[] segments = this.segments;
        long sum = 0;
        long check = 0;
        int[] mc = new int[segments.length];
        // Try a few times to get accurate count. On failure due to
        // continuous async changes in table, resort to locking.
        for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {
            check = 0;
            sum = 0;
            int mcsum = 0;
            for (int i = 0; i < segments.length; ++i) {
                sum += segments[i].count;
                mcsum += mc[i] = segments[i].modCount;
            }
            if (mcsum != 0) {
                for (int i = 0; i < segments.length; ++i) {
                    check += segments[i].count;
                    if (mc[i] != segments[i].modCount) {
                        check = -1; // force retry
                        break;
                    }
                }
            }
            if (check == sum)
                break;
        }
        if (check != sum) { // Resort to locking all segments
            sum = 0;
            for (int i = 0; i < segments.length; ++i)
                segments[i].lock();
            for (int i = 0; i < segments.length; ++i)
                sum += segments[i].count;
            for (int i = 0; i < segments.length; ++i)
                segments[i].unlock();
        }
        if (sum > Integer.MAX_VALUE)
            return Integer.MAX_VALUE;
        else
            return (int)sum;
    }

        上面size的过程就是,累加所有segment中的count,如果过程中segment中元素数量发生了变化,那么重试。如果重试了RETRIES_BEFORE_LOCK次(默认是2)都不行,那么将所有segment加锁,然后累加count,然后再解锁。在containsValue里面也是这么玩儿的,代码就不贴了。

 

  • 其他代码也很容易看懂了,就分析到这里。最后注意下,ConcurrentHashMap也提供了Key和Value的集合视图,它们和ConcurrentHashMap共享一份数据,它们的迭代器是弱一致的。

         ConcurrentHashMap的代码解析完毕!          参见:
Jdk1.6 JUC源码解析(7)-locks-ReentrantLock  

    原文作者:JUC
    原文地址: https://blog.csdn.net/iteye_11160/article/details/82642786
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞