ConcurrentHashMap 两个版本读源码笔记

JDK 1.7

数据结构

JDK 1.7 结构

Segment 分段锁

依旧是数组+链表,Segment 是一个 ReentrantLock 可重入锁:

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

数据操作的时候,先定位到 Segment 数组的位置,然后尝试获取锁。某个线程获取锁成功就进行数据添加、移除等操作,这时其它线程需要操作数据,会进入 Segment 的锁队列(AQS)并根据情况进入阻塞状态。等待独占线程释放锁后,后面的线程接着进行数据操作。

每一个 Segment 都是一个锁,各个锁之间互不影响。也就是当 Segment A 被某线程操作数据的时候,Segment B 依旧可以进行数据操作,这就是所谓 “锁分离” 的大概原理。这样分段锁的效率要高于整个数据加锁、也高于 synchronized 对方法加锁。

元素个体 HashEntry

HashEntry 数组是真正存放数据的地方:

static final class HashEntry<K,V> {
    final int hash; // hash值
    final K key; // key
    volatile V value; // value
    volatile HashEntry<K,V> next; // 下一个结点

    HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
}

要注意的是 value 和 next 结点都是 volatile 修饰的,保证了其可见性,也就是在读取的时候都是最新的值。

构造器

/**
 * 默认的初始容量 16
 */
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
 * 默认的负载因子
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
 * 默认的并发数量,会影响segments数组的长度(初始化后不能修改)
 */
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
 * 最大容量,构造ConcurrentHashMap时指定的值超过,就用该值替换
 * ConcurrentHashMap大小必须是2^n,且小于等于2^30
 */
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
 * 允许最大segment数量,用于限定concurrencyLevel的边界,必须是2^n
 */
static final int MAX_SEGMENTS = 1 << 16;
/**
 * 非锁定情况下调用size和contains方法的重试次数,避免由于table连续被修改导致无限重试
 */
static final int RETRIES_BEFORE_LOCK = 2;
/**
 * segments数组
 */
final Segment<K,V>[] segments;

构造器可指定默认初始容量,增长因子,并发等级(决定同一时间允许线程操作的数据)。

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    // MAX_SEGMENTS 为最大 Segment 数量,默认 1<<16=65536
    // 如果超过了最大容量,直接设置为最大
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    // 找到距离并发数最大的 2 的幂数,作为 Segment 数组的容量
    int sshift = 0;
    int ssize = 1;
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
    // 根据传来的参数,创建 Segment 模板 s0
    // 放置元素时需要初始化 Segment,需要用到这个模板
    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.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

数据存放

public V put(K key, V value) {
    Segment<K,V> s;
    // value 不可为 null
    if (value == null)
        throw new NullPointerException();
    // key 不可为 null,否则 hashCode 方法空指针
    int hash = hash(key.hashCode());
    // hash 码进行运算,相当于扰动一下
    int j = (hash >>> segmentShift) & segmentMask;
    // 根据 hash 值获取对应的 Segment
    if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
         (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
        s = ensureSegment(j);
    return s.put(key, hash, value, false);
}
  1. ConcurrentHashMap 键值不可为 null。至于为什么这么设计,有一种说法是为了避免多线程下获取数据,无法区分到底是没有该数据,还是该数据为 null 的情况。

  2. 定位 Segment 位置,如果不存在则创建 Segment。

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            // 尝试加锁
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                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;
                        // key 相同则准备覆盖值,覆盖成功跳出循环
                        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 {// 链表头结点为空
                        // 不为 null 
                        if (node != null)
                            // 将新结点放进链表首位,调用 putOrderedObject 进行内存地址偏移确定位置
                            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
                            // 头结点放在下标处,会调用 putOrderedObject 确定位置
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                // 最后释放锁
                unlock();
            }
            return oldValue;
        }
  1. 某个线程来到该方法,首先尝试获取锁。获取成功执行后续 put 操作,失败进行自旋尝试获取。如果重试次数最大则进入 AQS 队列,再根据其状态进行阻塞或中断等待获取。

scanAndLockForPut 再次尝试获取锁或阻塞。

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; // negative while locating node
            while (!tryLock()) {
                HashEntry<K,V> f; // to recheck first below
                if (retries < 0) {
                    if (e == null) {
                        if (node == null) // speculatively create node
                            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();// 进入 ReetLock 的 lock 方法,会进行排队或阻塞
                    break;
                }
                else if ((retries & 1) == 0 &&
                         (f = entryForHash(this, hash)) != first) {
                    e = first = f; // re-traverse if entry changed
                    retries = -1;
                }
            }
            return node;
        }
  1. 根据 hash 计算出下标,根据下标定位 HashEntry 数组的位置,新增的元素即将插入该位置并作为头结点。
  2. 紧接着遍历链表,如果新元素下标与已存在的相同,则覆盖值并退出循环。
  3. 遍历出现 null 的情况,要么是空桶、要么是遍历完了链表。然后将新增的元素添加到链表首位,UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e) 相当于把数据存放到合适的地址中去。

确定容量

每个 Segment 进行数据存放或删除时,会统计 modCount(编辑次数)和 count(元素数量)。

计算 size 时,进行三次遍历。如果最后两次的 modCount 相同说明近期没有发生数据变化,可以乐观的认为计算出的 count 就是最终数量。

如果最后两次统计的 modCount 不一致,说明近期数据可能发生了变化。只能把每个 Segment 锁住,然后计算它们的容量返回结果,最后释放锁。这个过程就挺悲观的了。

public int size() {
   // Try a few times to get accurate count. On failure due to
    // continuous async changes in table, resort to locking.
    final Segment<K,V>[] segments = this.segments;
    final int segmentCount = segments.length;

    long previousSum = 0L;
    for (int retries = -1; retries < RETRIES_BEFORE_LOCK; retries++) {
        long sum = 0L;    // sum of modCounts
        long size = 0L;
        for (int i = 0; i < segmentCount; i++) {
            Segment<K,V> segment = segmentAt(segments, i);
            if (segment != null) {
                sum += segment.modCount;
                size += segment.count;
            }
        }
        if (sum == previousSum)
            return ((size >>> 31) == 0) ? (int) size : Integer.MAX_VALUE;
        previousSum = sum;
    }

    long size = 0L;
    for (int i = 0; i < segmentCount; i++) {
        Segment<K,V> segment = ensureSegment(i);
        segment.lock();
        size += segment.count;
    }
    for (int i = 0; i < segmentCount; i++)
        segments[i].unlock();
    return ((size >>> 31) == 0) ? (int) size : Integer.MAX_VALUE;
}

扩容机制 rehash

当数组容量到达一定值(threshold)时,进行扩容。

if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);

threshold = 数组容量*增长因子。

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; // 生成新掩码,用于生成下标
    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; // 根据 hash 和新的掩码生成下标
            if (next == null)   //  只有一个元素的链表,直接放就好
                newTable[idx] = e;
            else { // 不止一个元素,遍历它,重新确定位置
                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;
                // 如果 p==lastRun 说明所有元素下标都未发生变化,也就不需要遍历了
                // 反之,把发生变化的链表位置重新归置一下
                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 获取元素

get 的过程是不加锁的,效率较高。首先根据 hash 值定位到 Segment 位置,然后再进行链表的遍历直到搜索到元素即可。

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    int h = hash(key.hashCode());
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
             // 弱一致性的的原因,遍历时该 Segment 可能已经更新
             // contains 方法也有同样的问题
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    return null;
}

为什么 get 过程不加锁,首先获取 Segment 的时使用的 UNSAFE.getObjectVolatile 方法,进行 volatile语义的读取。volatile 读取保证了该 Segment 在读取时是最新的,但是在遍历的时候,原 Segment 可能已经发生了变化,在使用时需要注意。

remove 移除元素

同样是先找到相应的 Segment,然后加锁进行移除,移除完毕释放锁。

public V remove(Object key) {
    int hash = hash(key.hashCode());
    Segment<K,V> s = segmentForHash(hash);
    return s == null ? null : s.remove(key, hash, null);
}
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;
}

JDK 1.8

数据结构

不再采用多个 Segment 结构,而是 Node 数组+链表/红黑树来存储数据。这样做优化了查询速度,由原来的链表查询 O(n) 优化为红黑树 O(logn)。

JDK 1.8 数据结构

元素个体:Node<K,V>

Node 结点的值 val 和 下一个结点 Node 都是 volatile 修饰的,保证了可见性(保证读取时是最新的)。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }

    public final K getKey()     { return key; }
    public final V getValue()   { return val; }
    public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
    public final String toString() {
        return Helpers.mapEntryToString(key, val);
    }
    ...

构造器

构造器之一,参数最多就贴出来。

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
    long size = (long)(1.0 + (long)initialCapacity / loadFactor);
    int cap = (size >= (long)MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : tableSizeFor((int)size);
    this.sizeCtl = cap;
}
  • initialCapacity:指定初始容量,默认的是 16。需要注意的是当初始容量小于并发数量,会直接等于并发数。
  • loadFactor:指定阈值,当容量大于该值进行扩容。
  • concurrencyLevel:并发数。

数据存放

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // 不可为 null
    if (key == null || value == null) throw new NullPointerException();
    // 1. 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)
            2. 初始化
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {// volaite 读取,要插入的位置为 null 说明当前下标没有数据,可创建头结点
            // CAS 插入数据,期望值 null 要修改的值新 Node
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // 3. 正在扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 4. volatile 只保证了 Node 值和下一个结点的可见性,并不保证原子性
            // 所以需要加锁
            synchronized (f) {
                // 找到结点下标位置
                if (tabAt(tab, i) == f) {
                    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;
                            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;
                        }
                    }
                    else if (f instanceof ReservationNode)
                        throw new IllegalStateException("Recursive update");
                }
            }
            if (binCount != 0) {
                // 超过 8 个转换为红黑树
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 5. 容量计算
    addCount(1L, binCount);
    return null;
}
  1. spread 方法先进行高 16 位与低 16 位进行异或,进行扰动。然后再和 HASH_BITS 进行 & 运算,也就是与 0111 1111X7 进行 & 运算,保证 hash 值不为负数顺便又进行一次扰动。
    因为负数定位了一些数据正在参与扩容、树节点转换、反转等信息,避免冲突。
static final int HASH_BITS = 0x7fffffff;
static final int spread(int h) {
     return (h ^ (h >>> 16)) & HASH_BITS;
 }
  1. table 为空的初始化,经典的 自旋+CAS。如果有线程正在初始化,则 CAS 标记一个数值表示正在初始化。当别的线程进来时,发现正在初始化,则 yield 让出 CPU。下次再进入自旋循环时,可能已经初始化完毕,进行后面的 put 操作了。
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0) // 小于 0 说明可能正在初始化中,转换为就绪状态,让出 cpu
            Thread.yield(); // lost initialization race; just spin
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {// CAS 一下,期望值 sc,要修改的值 -1。保证其它线程来到这里时不会影响正常初始化
            try {
                if ((tab = table) == null || tab.length == 0) {
                    // 默认 16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    // 减去除以 4,相当于 %75
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}
  1. 如果 hash 值为 MOVE,说明正在扩容

  2. 结点加同步,之后无非就是进行遍历。查询新插入的 key 是否重复,如果重复覆盖值。

  3. 容量计算,ConCurrentHashMap 使用一个 volatile 的 baseCount 来表示当前修改过后元素的个数。

private transient volatile long baseCount;

容量计算

ConCurrentHashMap 使用 CounterCells[] 数组和 baseCount 来存放和计算容量:

final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount;
    // 初始容量和遍历 CounterCell 数组存储的数量
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

CounterCells 对象包含一个数量属性,CounterCells 数组所有元素的数量属性加起来再加上 ConCurrentHashMap 的 baseCount 就是容量了。

CounterCells 初始化时默认容量是 2。当一个线程添加数据时,首先生成线程的哈希指针(相当于随机数,但是比 Radom 性能要好),然后将哈希指针和 CounterCells 容量-1 进行 & 运算。这与 HashMap 确认下标的过程类似,然后将创建 CounterCells 对象设置容量,再赋值到 CounterCells 数组中。

扩容机制

扩容条件:当前容量超过阈值。
transfer 当容量不足时进行扩容。这块内容比较复杂,暂时略过。

private final void addCount(long x, int check) {
    ...
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        // s 是计算出的元素数量,超过阈值 sizeCtl 触发扩容
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

get 获取元素

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode());
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

get 比较简单,先确认 hash 桶的位置,然后遍历直到找到并返回 value 为止。找不到返回 null。

这个过程无需加锁,效率较高。因为 Node 结点的 value 是 volatile 修饰的,保证了读取的可见性。

推荐阅读更多精彩内容