【Explore SRC】查阅ConcurrentHashMap笔记

看ConcurrentHashMap的，一般都看过HashMap的了，那么我们就直奔主题吧。

> 参考的优秀文章

Java集合---ConcurrentHashMap原理分析

> 构造方法

/**
 * The default concurrency level for this table, used when not
 * otherwise specified in a constructor.
 */
static final int DEFAULT_CONCURRENCY_LEVEL = 16;

......

public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel)

直接来到这个构造方法，可以看到，默认的concurrencyLevel为16，可以理解为分16个segment，操作时以segment为粒度大小加锁。

在HashMap基础上增加了：

1、计算segmentShift、segmentMask（用途下面会提到）

2、计算cap，实例化ss（segment的数组）、s0（第一个segment）（用途下面会提到）

 

int sshift = 0;
int ssize = 1;
while (ssize < concurrencyLevel) {
    ++sshift;
    ssize <<= 1;
}
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;

这段代码为了计算segmentShift（如需加入某元素，将它分配到某个segment需移动的位数）、segmentMask（此掩码用于计算分配到哪个segment）

concurrencyLevel可以看为分多少个segment，即segment[]的长度

segmentMask这个掩码后面被用来跟hash值的高位做&操作，从而确定分配到哪个segment；

sshift为segmentMask二进制的位数，用来求segmentShift；

而segmentShift后面用来为hash值右移的位数，从而获取hash的高多少位来做&运算。

 

这段代码简单打印各个值，便于理解：

public class SegmentShiftMask {

    public static void main(String[] args) {
        for (int i = 1; i < 20; i++) {
            test(i);
        }
    }
    
    public static void test(int concurrencyLevel) {
        int sshift = 0;
        int ssize = 1;
        while (ssize < concurrencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
        int segmentShift = 32 - sshift;
        int segmentMask = ssize - 1;
        
        System.out.println("concurrencyLevel : " + concurrencyLevel + " \t= " + String.format("%08d", Integer.valueOf(Integer.toBinaryString(concurrencyLevel))));
        System.out.println("sshift           : " + sshift);
        System.out.println("segmentShift     : " + segmentShift);
        System.out.println("segmentMask      : " + segmentMask + " \t= " + String.format("%08d", Integer.valueOf(Integer.toBinaryString(segmentMask))));
        System.out.println("--------");
    }

}

打印结果：

concurrencyLevel : 15     = 00001111
sshift           : 4
segmentShift     : 28
segmentMask      : 15     = 00001111
--------
concurrencyLevel : 16     = 00010000
sshift           : 4
segmentShift     : 28
segmentMask      : 15     = 00001111
--------
concurrencyLevel : 17     = 00010001
sshift           : 5
segmentShift     : 27
segmentMask      : 31     = 00011111
--------
concurrencyLevel : 18     = 00010010
sshift           : 5
segmentShift     : 27
segmentMask      : 31     = 00011111
--------
concurrencyLevel : 19     = 00010011
sshift           : 5
segmentShift     : 27
segmentMask      : 31     = 00011111
--------

 

int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
    ++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
    cap <<= 1;

这段是求cap（segment中包含的table数组的大小），这个cap的大小是2的N次方。

 

int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;

计算key的哈希值，右移segmentShift取哈希值的高位，再与掩码做&运算，得到j就是该把插入的元素放在segment[]的哪个位置了。

 

if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
     (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
    s = ensureSegment(j);

获取segment。

 

return s.put(key, hash, value, false);

......

static final class Segment<K,V> extends ReentrantLock implements Serializable {

......

    final V put(K key, int hash, V value, boolean onlyIfAbsent) {
        HashEntry<K,V> node = tryLock() ? null :
            scanAndLockForPut(key, hash, value);
        V oldValue;
            try {
        ......
        
        } finally {
            unlock();
        }
        return oldValue;
    }
    
......

}

Segment以ReentrantLock方式加锁，保证线程安全，且加锁的范围在Segment，不像HashTable整体加锁了。

scanAndLockForPut()中tryLock()尝试非阻塞方式获取锁并计算尝试次数，到一定次数后在使用中lock()阻塞方式获取锁。

 

HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
    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 {
        if (node != null)
            node.setNext(first);
        else
            node = new HashEntry<K,V>(hash, key, value, first);
        int c = count + 1;
        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
            rehash(node);
        else
            setEntryAt(tab, index, node);
        ++modCount;
        count = c;
        oldValue = null;
        break;
    }
}

......

static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry<K,V> next;
......

hash与tab.length做&操作，获取该放在哪个下标指向。覆盖数据、新增数据的逻辑与HashMap类似。

 

> 附

本文并未完整地描述ConcurrentHashMap的整体概括，只记录笔者浏览的部分笔记。

 

部分图纸笔记：