Java 7 ConcurrentHashMap源码解析

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/GD_Hacker/article/details/81530405

记录阅读Java 7 ConcurrentHashMap源码的过程，阅读前建议先了解ConcurrentHashMap与HashMap异同，以及对ConcurrentHashMap大致结构有个印象。另外还需要了解Unsafe类，Reentrantlock机制。

---

部分关键成员变量

• static final int DEFAULT_INITIAL_CAPACITY = 16;
  默认初始化容量，这里说的容量是指总容量，即每个Segment分到的容量之和

• static final float DEFAULT_LOAD_FACTOR = 0.75f;
  默认加载因子，由于Segment是无法扩容的，所以这里针对的是Segment中的table

• static final int DEFAULT_CONCURRENCY_LEVEL = 16;
  直译是默认并发级别，首先需要知道ConcurrentHashMap为了控制并发，采用的是Segment锁，也就是同一时间每个Segment只允许一个线程写入，而且其他线程不能读取。所以，对于n个Segment，也就允许n个线程并发写入。因此这里可以理解为初始Segment数量。

• static final int MAXIMUM_CAPACITY = 1 << 30;
  最大允许容量

• static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
  每个Segment中table的最小容量

• static final int MAX_SEGMENTS = 1 << 16;
  最大Segment容量数

---

构造方法

先附源码：

//initialCapacity 初始容量，指的是全局容量
//loadFactor 加载因子
//concurrentLevel 并发级别
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;
    // Find power-of-two sizes best matching arguments
    int sshift = 0;//移位数
    int ssize = 1;//Segment大小
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;//保证值为2^n
    }
    //这两个参数之后会用到，先有个印象
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize;//计算每个Segment分到的大小
    if (c * ssize < initialCapacity)
        ++c;
    //这里默认每个Segment最小table大小为2，这样可以保证至少在第一次插入时不会扩容，第二次插入才进行resize，提升性能
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    //这里保证每个Segment中的table大小保持为2^n
    while (cap < c)
        cap <<= 1;
    // create segments and segments[0]
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                         (HashEntry<K,V>[])new HashEntry[cap]);
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
    //调用Unsafe类方法，由于是native方法，不好查看源码，这里记住这个方法为向ss数组中插入Segment
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    //segments是用final修饰，一旦初始化后，segments的值就无法改变
    this.segments = ss;
}

为了方便理解，我们取一组数据分析：

全局容量：initialCapacity=16
加载因子：loadFactor=0.75f
并发级别：concurrencyLevel=16

移位数(中间值)：sshift=4
Segment大小：ssize=16

Segment移位数：segmentShift = 32 - sshift=28
Segment掩码：segmentMask = ssize - 1=15

每个Segment平均容量(中间值)：c=initialCapacity / ssize=1
每个Segment平均容量:cap = MIN_SEGMENT_TABLE_CAPACITY=2

new Segment<K,V>：Segment的构造方法也比较好理解，传入加载因子loadFactor，传入阈值(int) (cap * loadFactor)，传入存放key-value的table(HashEntry<K,V>[])new HashEntry[cap])。这里需要先初始化Segment[0] 是有原因的，之后再分析。

---

put()

public V put(K key, V value) {
    Segment<K,V> s;
    //与HashMap不同，key和value都不能为空，再调用下面hash(key)方法时，如果key为空也会报空指针异常
    if (value == null)
        throw new NullPointerException();
    //获取key的hash值
    int hash = hash(key);
    //segmentShift和segmentMask是用来计算Segment数组下标的！
    //上面我们取值为28和15，可以代入计算一下，将32位的hash先无符号右移28位，然后将低4位和segmentMask相与得到数组下标
    int j = (hash >>> segmentShift) & segmentMask;
    //利用Unsafe类getObject方法直接从内存中取出指定偏移量的Segment实例对象
    if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
         (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
        //如果实例对象为空，需要先初始化segments[j]
        s = ensureSegment(j);
    return s.put(key, hash, value, false);
}

对put()方法总体有个认识后，我们来“肢解”里面一些方法：

int hash(Object k)

private int hash(Object k) {
    int h = hashSeed;

    if ((0 != h) && (k instanceof String)) {
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();

    // 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);
}

之前提及到，确定Segment下标是通过将hash值与segments数组长度低四位相与得到，试想下，如果有两个hash值，它们的高28位不同，但是低四位相同，那么相与的结果也是相同的，造成了hash冲突，所以ConcurrentHashMap对获取hash的方法进行了封装，在hash()方法进行了一连串的位运算，目的就是令高位的不同会造成hash值低位的变化，这样获取的j就不同了。

Segment<K,V> ensureSegment(int k)

private Segment<K,V> ensureSegment(int k) {
    final Segment<K,V>[] ss = this.segments;
    //获取内存偏移地址
    long u = (k << SSHIFT) + SBASE; // raw offset
    Segment<K,V> seg;
    if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        //这里就说明了为什么要先初始化segments[0]
        //直接copy segments[0]当前（因为segments[0]可能已经扩容过）的table容量大小、加载因子和阈值来初始化segments[j]
        Segment<K,V> proto = ss[0]; // use segment 0 as prototype
        int cap = proto.table.length;
        float lf = proto.loadFactor;
        int threshold = (int)(cap * lf);
        HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
            == null) { // recheck
            Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
            while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                   == null) {
                //采用CAS，保证在线程安全状况下写入segments数组
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                    break;
            }
        }
    }
    return seg;
}

这里我简单说一下在这个方法中CAS以及四个参数的作用

• 第一个参数是需要写入的目标对象，这里是segments数组
• 第二个参数指内存偏移量
• 第三个参数是期望的内存值，这里期望是null
• 第四个参数是需要更新的值

大概思路为：第一次从内存中读取到某个值，记为a，内存偏移量记为u；现在需要将新的值，记为b，写入到内存中偏移量为u处，为了避免在我第一次读取，到写入这段时间，其他线程对该内存值进行了修改，所以我将之前记录的值a与此时此刻的内存值进行对比，如果相同，则可以认为没有其他线程修改过，我就可以将新的值b写入到内存中，保证了线程安全。当然，也有可能其他线程曾经修改过，只是修改的值与原值一样，所以我还可以加个版本号来控制，每次修改后版本号+1，这样直接对比版本是否相同就可以确认有没有被修改过。

V put(K key, int hash, V value, boolean onlyIfAbsent)

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    //尝试获取锁，如果失败，会进入scanAndLockForPut轮询获取
    HashEntry<K,V> node = tryLock() ? null :
        scanAndLockForPut(key, hash, value);
    V oldValue;
    try {
        //table数组即是Segment中存放key-value的数组
        HashEntry<K,V>[] tab = table;
        //利用之前得到的hash,计算存放在table的下标
        int index = (tab.length - 1) & hash;
        //获取链表第i个节点，既是table[i]
        HashEntry<K,V> first = entryAt(tab, index);
        //分两种情况：链不为空，遍历链，如果key相同，替换并返回旧值；
        //链为空或者已经遍历至末尾，将新的key-value插入到链表头
        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 {
                //node的值依赖获取锁的操作，之后再介绍这里的逻辑，现在只需要知道这里的if-else操作是将新的key-value设为链表头
                if (node != null)
                    node.setNext(first);
                else
                    node = new HashEntry<K,V>(hash, key, value, first);
                //判断是否需要扩容，count记录的是当前Segment中table数组已存入值的数量    
                int c = count + 1;
                if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                    //扩容并将node插入到扩容后的table中
                    rehash(node);
                else
                    setEntryAt(tab, index, node);//将node放入table
                ++modCount;//与fast-fail机制有关
                count = c;
                oldValue = null;
                break;
            }
        }
    } finally {
        unlock();
    }
    return oldValue;
}

HashEntry<K,V> scanAndLockForPut(K key, int hash, V value)

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
    //从当前Segment的table中获取指定hash的HashEntry实例
    HashEntry<K,V> first = entryForHash(this, hash);
    HashEntry<K,V> e = first;
    HashEntry<K,V> node = null;
    //retries控制流程
    int retries = -1; // negative while locating node
    while (!tryLock()) {
        HashEntry<K,V> f; // to recheck first below
        if (retries < 0) {
            if (e == null) {
                //初始化node
                if (node == null) // speculatively create node
                    node = new HashEntry<K,V>(hash, key, value, null);
                retries = 0;
            }
            //如果找到指定的key
            else if (key.equals(e.key))
                retries = 0;
            else
                e = e.next;
        }
        else if (++retries > MAX_SCAN_RETRIES) {
            //如果重试次数已达到上限，执行lock()；除非获取到锁，否则当前线程处于阻塞状态
            lock();
            break;
        }
        else if ((retries & 1) == 0 &&
                 (f = entryForHash(this, hash)) != first) {
            //retries为偶数时，重新检查链表，如果由于并发，原位置节点发生改变，重新走一遍流程      
            e = first = f; // re-traverse if entry changed
            retries = -1;
        }
    }
    return node;
}

static final <K,V> HashEntry<K,V> entryForHash(Segment<K,V> seg, int h) {
    HashEntry<K,V>[] tab;
    return (seg == null || (tab = seg.table) == null) ? null :
        (HashEntry<K,V>) UNSAFE.getObjectVolatile
        (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
}

逻辑是这样的：在上面的put方法中，首先尝试获取一次锁，如果获取失败，证明该Segment存在并发，进入到entryForHash方法轮询获取锁，为了提高效率，轮询过程中预先创建node实例。所以，归结起来，scanAndLockForPut方法最主要完成的两件事就是：轮询取锁和创建node实例。

rehash

private void rehash(HashEntry<K,V> node) {

    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;//求取table下标的掩码值
    //遍历每个HashEntry，重新计算下标并迁移到扩容后的table
    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)   //  Single node on list
                newTable[idx] = e;
            else { // Reuse consecutive sequence at same slot
                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;
                // Clone remaining nodes
                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);
                }
            }
        }
    }
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    table = newTable;
}

---

get()

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    int h = hash(key);
    //计算指定的Segment在内存中的偏移值
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    //获取Segment并判断table是否存在
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        //再次利用hash求出table[i]内存偏移值，遍历HashEntry链，查找是否有相同的key
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    return null;
}

get()方法简直不要太简单，思路也非常好理解。

---

附上涉及到UNSAFE的常量介绍（纯属个人理解，可能会有错误的地方，请斟酌参考）

static {
    int ss, ts;
    try {
        //获取Unsafe实例
        UNSAFE = sun.misc.Unsafe.getUnsafe();
        //获取一维数组的类对象，对象数组是在运行时由虚拟机自动创建
        Class tc = HashEntry[].class;
        Class sc = Segment[].class;
        //数组类对象在内存的基值（可以理解成操作系统中的段式存储，先找到哪个段，然后再确定段中的偏移量）
        TBASE = UNSAFE.arrayBaseOffset(tc);
        SBASE = UNSAFE.arrayBaseOffset(sc);
        //数组规模，可以理解成数组的大小
        ts = UNSAFE.arrayIndexScale(tc);
        ss = UNSAFE.arrayIndexScale(sc);
        //获取ConcurrentHashMap中字段的偏移值，反射获取的字段对象作为传入参数
        HASHSEED_OFFSET = UNSAFE.objectFieldOffset(
            ConcurrentHashMap.class.getDeclaredField("hashSeed"));
        SEGSHIFT_OFFSET = UNSAFE.objectFieldOffset(
            ConcurrentHashMap.class.getDeclaredField("segmentShift"));
        SEGMASK_OFFSET = UNSAFE.objectFieldOffset(
            ConcurrentHashMap.class.getDeclaredField("segmentMask"));
        SEGMENTS_OFFSET = UNSAFE.objectFieldOffset(
            ConcurrentHashMap.class.getDeclaredField("segments"));
    } catch (Exception e) {
        throw new Error(e);
    }
    //保证Segment[]和HashEntry[]数组规模为二次幂
    if ((ss & (ss-1)) != 0 || (ts & (ts-1)) != 0)
        throw new Error("data type scale not a power of two");
    //基于BASE的偏移量        
    SSHIFT = 31 - Integer.numberOfLeadingZeros(ss);
    TSHIFT = 31 - Integer.numberOfLeadingZeros(ts);
}