ConcurrentHashMap.Segment源码解析

ConcurrentHashMap通过将完整的表分成若干个segment的方式实现锁分离，每个segment都是一个独立的线程安全的Hash表，当需要操作数据时，HashMap通过Key的hash值和segment数量来路由到某个segment，剩下的操作交给segment来完成。

下面来看下segment的实现：

segment是一类特殊的hash表，继承了ReentrantLock类实现锁功能

    static final class Segment<K,V> extends ReentrantLock implements Serializable {
    /*
    1.segment的读操作不需要加锁，但需要volatile读
    2.当进行扩容时(调用reHash方法)，需要拷贝原始数据，在拷贝数据上操作，保证在扩容完成前读操作仍可以在原始数据上进行。
    3.只有引起数据变化的操作需要加锁。
    4.scanAndLock(删除、替换)/scanAndLockForPut(新增)两个方法提供了获取锁的途径，是通过自旋锁实现的。
    5.在等待获取锁的过程中，两个方法都会对目标数据进行查找，每次查找都会与上次查找的结果对比，虽然查找结果不会被调用它的方法使用，但是这样做可以减少后续操作可能的cache miss。
         */

        private static final long serialVersionUID = 2249069246763182397L;

		 /*
		 自旋锁的等待次数上限，多处理器时64次，单处理器时1次。
		 每次等待都会进行查询操作，当等待次数超过上限时，不再自旋，调用lock方法等待获取锁。
		 */
        static final int MAX_SCAN_RETRIES =
            Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
		 /*
		 segment中的hash表，与hashMap结构相同，表中每个元素都是一个链表。
		 */
        transient volatile HashEntry<K,V>[] table;

        /*
         表中元素个数
         */
        transient int count;

        /*
        记录数据变化操作的次数。
        这一数值主要为Map的isEmpty和size方法提供同步操作检查，这两个方法没有为全表加锁。
        在统计segment.count前后，都会统计segment.modCount，如果前后两次值发生变化，可以判断在统计count期间有segment发生了其它操作。
         */
        transient int modCount;

        /*
        容量阈值，超过这一数值后segment将进行扩容，容量变为原来的两倍。
        threshold = loadFactor*table.length
         */
        transient int threshold;

        final float loadFactor;

        Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
            this.loadFactor = lf;
            this.threshold = threshold;
            this.table = tab;
        }
		 /*
		 onlyIfAbsent:若为true，当key已经有对应的value时，不进行替换；
		 若为false，即使key已经有对应的value，仍进行替换。

		 关于put方法，很重要的一点是segment最大长度的问题：
		 代码 c > threshold && tab.length < MAXIMUM_CAPACITY 作为是否需要扩容的判断条件。
		 扩容条件是node总数超过阈值且table长度小于MAXIMUM_CAPACITY也就是2的30次幂。
		 由于扩容都是容量翻倍，所以tab.length最大值就是2的30次幂。此后，即使node总数超过了阈值，也不会扩容了。
		 由于table[n]对应的是一个链表，链表内元素个数理论上是无限的，所以segment的node总数理论上也是无上限的。
		 ConcurrentHashMap的size()方法考虑到了这个问题，当计算结果超过Integer.MAX_VALUE时，直接返回Integer.MAX_VALUE.

		 */
        final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            //tryLock判断是否已经获得锁.
            //如果没有获得，调用scanAndLockForPut方法自旋等待获得锁。
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                //计算key在表中的下标
                int index = (tab.length - 1) & hash;
                //获取链表的第一个node
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                //链表下一个node不为空，比较key值是否相同。
                //相同的，根据onlyIfAbsent决定是否替换已有的值
                    if (e != null) {
                        K k;
                        if ((k = e.key) == key ||
                            (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;
                    }
                    else {
                    //链表遍历到最后一个node，仍没有找到key值相同的.
                    //此时应当生成新的node，将node的next指向链表表头，这样新的node将处于链表的【表头】位置
                        if (node != null)
                        //scanAndLockForPut当且仅当hash表中没有该key值时
                        //才会返回新的node，此时node不为null
                            node.setNext(first);
                        else
                        //node为null，表明scanAndLockForPut过程中找到了key值相同的node
                        //可以断定在等待获取锁的过程中，这个node被删除了，此时需要新建一个node
                            node = new HashEntry<K,V>(hash, key, value, first);
                        //添加新的node涉及到扩容，当node数量超过阈值时，调用rehash方法进行扩容，并将新的node加入对应链表表头；
                        //没有超过阈值，直接加入链表表头。
                        int c = count + 1;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

        /*
         hash表容量翻倍，将需要添加的node添加到扩容后的表中。
         hash表默认初始长度为16，实际长度总是2的n次幂。
         设当前table长度为S，根据key的hash值计算table中下标index的公式：
         扩容前:oldIndex = (S-1)&hash
         扩容后:newIndex = (S<<1-1)&hash
         扩容前后下标变化:newIndex-oldIndex = S&hash
         所以，扩容前后node所在链表在table中的下标要么不变，要么右移2的幂次。
         根据本方法官方注释说明，大约六分之一的node需要复制操作。

         对于每个链表，处理方法如下：

         步骤一：对于链表中的每个node，计算node和node.next的新下标，如果它们不相等，记录最后一次出现这种情况时的node.next，记为nodeSpecial。
         这一部分什么意思呢，假设table[n]所在的链表共有6个node，计算它们的新下标：
         情况1：若计算结果为0:n,1:n+S,2:n,3:n+2,4:n,5:n，那么我们记录的特殊node编号为4；
         情况2：若计算结果为0:n,1:n+S,2:n,3:n+2,4:n+4,5:n+8，那么我们记录的特殊node编号为5；
         情况3：若计算结果为0:n,1:n,2:n,3:n,4:n,5:n,特殊node为0;
         情况4：若计算结果为0:n+S,1:n+S,2:n+S,3:n+S,4:n+S,5:n+S,特殊node为0。
         很重要的一点，由于新下标只可能是n或n+S，因此这两个位置的链表中不会出现来自其它链表的node。
         对于情况3，令table[n]=node0，进入步骤三；
         对于情况4，令table[n+S]=node0，进入步骤三；
         对于情况1，令table[n]=node4，进入步骤二；
         对于情况2，令table[n+S]=node3,进入步骤二。

         步骤二：从node0遍历至nodeSpecial的前一个node，对于每一个node，调用HashEntry构造方法复制这个node，放入对应的链表。

         步骤三：计算需要新插入的node的下标index，同样令node.next=table[index],table[index]=node,将node插入链表表头。

         通过三步完成了链表的扩容和新node的插入。

         在理解这一部分代码的过程中，牢记三点：
         1.调用rehash方法的前提是已经获得了锁，所以扩容过程中不存在其他线程修改数据；
         2.新的下标只有两种情况，原始下标n或者新下标n+S；
         3.通过2可以推出，原表中不在同一链表的node，在新表中仍不会出现在同一链表中。
         */
        @SuppressWarnings("unchecked")
        private void rehash(HashEntry<K,V> node) {
            //拷贝table，所有操作都在oldTable上进行，不会影响无需获得锁的读操作
            HashEntry<K,V>[] oldTable = table;
            int oldCapacity = oldTable.length;
            int newCapacity = oldCapacity << 1;//容量翻倍
            threshold = (int)(newCapacity * loadFactor);//更新阈值
            HashEntry<K,V>[] newTable =
                (HashEntry<K,V>[]) new HashEntry[newCapacity];
            int sizeMask = newCapacity - 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;//新的table下标，定位链表
                    if (next == null)
                    	//链表只有一个node，直接赋值
                        newTable[idx] = e;
                    else {
                        HashEntry<K,V> lastRun = e;
                        int lastIdx = idx;
                        //这里获取特殊node
                        for (HashEntry<K,V> last = next;
                             last != null;
                             last = last.next) {
                            int k = last.hash & sizeMask;
                            if (k != lastIdx) {
                                lastIdx = k;
                                lastRun = last;
                            }
                        }
                        //步骤一中的table[n]赋值过程
                        newTable[lastIdx] = lastRun;
                        // 步骤二，遍历剩余node，插入对应表头
                        for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                            V v = p.value;
                            int h = p.hash;
                            int k = h & sizeMask;
                            HashEntry<K,V> n = newTable[k];
                            newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                        }
                    }
                }
            }
            //步骤三，处理需要插入的node
            int nodeIndex = node.hash & sizeMask;
            node.setNext(newTable[nodeIndex]);
            newTable[nodeIndex] = node;
            //将扩容后的hashTable赋予table
            table = newTable;
        }

        /*
        put方法调用本方法获取锁，通过自旋锁等待其他线程释放锁。
        变量retries记录自旋锁循环次数，当retries超过MAX_SCAN_RETRIES时，不再自旋，调用lock方法等待锁释放。
        变量first记录hash计算出的所在链表的表头node，每次循环结束，重新获取表头node，与first比较，如果发生变化，说明在自旋期间，有新的node插入了链表，retries计数重置。
        自旋过程中，会遍历链表，如果发现不存在对应key值的node，创建一个，这个新node可以作为返回值返回。
         根据官方注释，自旋过程中遍历链表是为了缓存预热，减少hash表经常出现的cache miss
         */
        private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
            HashEntry<K,V> first = entryForHash(this, hash);
            HashEntry<K,V> e = first;
            HashEntry<K,V> node = null;
            int retries = -1; //自旋次数计数器
            while (!tryLock()) {
                HashEntry<K,V> f;
                if (retries < 0) {
                    if (e == null) {
                    //链表为空或者遍历至链表最后一个node仍没有找到匹配
                        if (node == null)
                            node = new HashEntry<K,V>(hash, key, value, null);
                        retries = 0;
                    }
                    else if (key.equals(e.key))
                        retries = 0;
                    else
                        e = e.next;
                }
                else if (++retries > MAX_SCAN_RETRIES) {
                    lock();
                    break;
                }
                else if ((retries & 1) == 0 &&
                         (f = entryForHash(this, hash)) != first) {
                //比较first与新获得的链表表头node是否一致，如果不一致，说明该链表别修改过，自旋计数重置
                    e = first = f;
                    retries = -1;
                }
            }
            return node;
        }

        /*
        remove,replace方法会调用本方法获取锁，通过自旋锁等待其他线程释放锁。
        与scanAndLockForPut机制相似。
         */
        private void scanAndLock(Object key, int hash) {
            // similar to but simpler than scanAndLockForPut
            HashEntry<K,V> first = entryForHash(this, hash);
            HashEntry<K,V> e = first;
            int retries = -1;
            while (!tryLock()) {
                HashEntry<K,V> f;
                if (retries < 0) {
                    if (e == null || key.equals(e.key))
                        retries = 0;
                    else
                        e = e.next;
                }
                else if (++retries > MAX_SCAN_RETRIES) {
                    lock();
                    break;
                }
                else if ((retries & 1) == 0 &&
                         (f = entryForHash(this, hash)) != first) {
                    e = first = f;
                    retries = -1;
                }
            }
        }

        /*
        删除key-value都匹配的node，删除过程很简单：
        1.根据hash计算table下标index。
        2.根据index定位链表，遍历链表node，如果存在node的key值和value值都匹配，删除该node。
        3.令node的前一个节点pred的pred.next = node.next。
         */
        final V remove(Object key, int hash, Object value) {
            //获得锁
            if (!tryLock())
                scanAndLock(key, hash);
            V oldValue = null;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> e = entryAt(tab, index);
                HashEntry<K,V> pred = null;
                while (e != null) {
                    K k;
                    HashEntry<K,V> next = e.next;
                    if ((k = e.key) == key ||
                        (e.hash == hash && key.equals(k))) {
                        V v = e.value;
                        if (value == null || value == v || value.equals(v)) {
                            if (pred == null)
                                setEntryAt(tab, index, next);
                            else
                                pred.setNext(next);
                            ++modCount;
                            --count;
                            oldValue = v;
                        }
                        break;
                    }
                    pred = e;
                    e = next;
                }
            } finally {
                unlock();
            }
            return oldValue;
        }
		/*
		找到hash表中key-oldValue匹配的node，替换为newValue,替换过程与replace方法类似，不再赘述了。
		*/
        final boolean replace(K key, int hash, V oldValue, V newValue) {
            if (!tryLock())
                scanAndLock(key, hash);
            boolean replaced = false;
            try {
                HashEntry<K,V> e;
                for (e = entryForHash(this, hash); e != null; e = e.next) {
                    K k;
                    if ((k = e.key) == key ||
                        (e.hash == hash && key.equals(k))) {
                        if (oldValue.equals(e.value)) {
                            e.value = newValue;
                            ++modCount;
                            replaced = true;
                        }
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return replaced;
        }

        final V replace(K key, int hash, V value) {
            if (!tryLock())
                scanAndLock(key, hash);
            V oldValue = null;
            try {
                HashEntry<K,V> e;
                for (e = entryForHash(this, hash); e != null; e = e.next) {
                    K k;
                    if ((k = e.key) == key ||
                        (e.hash == hash && key.equals(k))) {
                        oldValue = e.value;
                        e.value = value;
                        ++modCount;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }
		 /*
		 清空segment，将每个链表置为空，count置为0，剩下的工作交给GC。
		 */
        final void clear() {
            lock();
            try {
                HashEntry<K,V>[] tab = table;
                for (int i = 0; i < tab.length ; i++)
                    setEntryAt(tab, i, null);
                ++modCount;
                count = 0;
            } finally {
                unlock();
            }
        }
    }

以上就是ConcurrentHashMap中关于segment部分的源码。可以看出，关于修改操作的线程安全已经被封装在segment中，甚至在ConcurrentHashMap中都不需要关心锁的问题。可以说，segment是整个ConcurrentHashMap的核心和关键。

版权声明：本文为博主原创文章，未经博主允许不得转载.