并发编程学习笔记（二十六、ConcurrentHashMap，Java7 ConcurrentHashMap）

目录：

• 什么是ConcurrentHashMap
• 为什么要有ConcurrentHashMap
• ConcurrentHashMap源码解析

什么是ConcurrentHashMap

ConcurrentHashMap，从名字上就可以看出它是一个处理并发情况的哈希表，和HashMap非常像，你可以把它当成是HashMap的扩展类。

为什么要有ConcurrentHashMap

我们知道HashMap是一个非线程安全的哈希表，其内部的函数都是没有加锁的，而实际的开发过程中需要处理并发情况下的Map也不少。

即使JDK已经提供了Hashtable这种线程安全的哈希表，但它的实现方式过于暴力了，它把所有的函数都加上了synchronize，这样的方式虽然可以保证线程安全，但并发度非常的低（所有的读写线程使用一把锁）。

就是在这种情况下ConcurrentHashMap应运而生，它可以使得读不加锁，写也仅仅只是锁住将要写的那个槽。

——————————————————————————————————————————————————————————————————————

小贴士：

还有一种同步map的方法，就是使用Collections工具类中synchronizedMap；它的原理和Hashtable差不多，也是使用synchronize对其内部的mutex对象加锁。

我截取了其部分代码粘出来，你可以看看。

private static class SynchronizedMap<K,V>
    implements Map<K,V>, Serializable {
    private static final long serialVersionUID = 1978198479659022715L;

    private final Map<K,V> m;     // Backing Map
    final Object      mutex;        // Object on which to synchronize

    SynchronizedMap(Map<K,V> m) {
        if (m==null)
            throw new NullPointerException();
        this.m = m;
        mutex = this;
    }

    SynchronizedMap(Map<K,V> m, Object mutex) {
        this.m = m;
        this.mutex = mutex;
    }

    public int size() {
        synchronized (mutex) {return m.size();}
    }
    public boolean isEmpty() {
        synchronized (mutex) {return m.isEmpty();}
    }
    public boolean containsKey(Object key) {
        synchronized (mutex) {return m.containsKey(key);}
    }
    public boolean containsValue(Object value) {
        synchronized (mutex) {return m.containsValue(value);}
    }
    public V get(Object key) {
        synchronized (mutex) {return m.get(key);}
    }

    public V put(K key, V value) {
        synchronized (mutex) {return m.put(key, value);}
    }
    public V remove(Object key) {
        synchronized (mutex) {return m.remove(key);}
    }
    public void putAll(Map<? extends K, ? extends V> map) {
        synchronized (mutex) {m.putAll(map);}
    }
    public void clear() {
        synchronized (mutex) {m.clear();}
    }
}

ConcurrentHashMap源码解析

我还是和往常一样从内部类、构造函数、核心方法这三个方面来介绍。

在介绍前，我们先看下ConcurrentHashMap的核心数据结构：

内部类：

1、Segment：

其最主要的结构就是Segment，它里面包含了HashMap中常用的属性及操作，其实啊总得来说它就是一个继承与ReentrantLock且对HashMap进行包装的一个可重入锁对象。

static final class Segment<K,V> extends ReentrantLock implements Serializable {
    transient volatile HashEntry<K,V>[] table;
    transient int count;
    transient int modCount;
    transient int threshold;
    final float loadFactor;
    
    Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
        this.loadFactor = lf;
        this.threshold = threshold;
        this.table = tab;
    }

    final V put(K key, int hash, V value, boolean onlyIfAbsent) {
        // 省略实现
    }

    private void rehash(HashEntry<K,V> node) {
        // 省略实现
    }
}

与HashMap不同的是HashMap只需要进行一次hash就可以计算出槽的位置，但ConcurrentHashMap需要先hash定位到对象的Segment，再hash定位到实际存储数据的槽。

——————————————————————————————————————————————————————————————————————

2、HashEntry：

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

与HashMap的结构基本一致，不同的是其内部的value、next使用volatile修饰，以保证内存的可见性，即读写操作对其它线程可见。

 

构造函数：

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与2的几次方最近，如concurrencyLevel=5，则与2^3=8最近，则sshift=3，sszie=8
    int sshift = 0;
    int ssize = 1;
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    // segmentShift和segmentMask主要用于元素的hash
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    // 得到分段锁segment中HashEntry[]大小
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
    // 创建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;
}

核心方法：

1、java.util.concurrent.ConcurrentHashMap#put：

public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null)
        throw new NullPointerException();
    // 计算key的hash值
    int hash = hash(key);
    // 无符号右移segmentShift位（默认16），然后&segmentMask（默认15），最后得到segment在内存中的地址
    int j = (hash >>> segmentShift) & segmentMask;
    // 如果拿到的segment为null
    if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
         (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
        // 则初始化segment
        s = ensureSegment(j);
    return s.put(key, hash, value, false);
}

其实这段逻辑主要就是找到segment的下标然后再存到HashEntry中。

2、java.util.concurrent.ConcurrentHashMap.Segment#put：

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 {
        HashEntry<K,V>[] tab = table;
        // 计算传入hash应在哪个槽
        int index = (tab.length - 1) & hash;
        // 拿到对应的槽的表头
        HashEntry<K,V> first = entryAt(tab, index);
        // 遍历整个链表
        for (HashEntry<K,V> e = first;;) {
            // 若果这个key要存入的槽已经有了节点（链表指针非空）
            if (e != null) {
                K k;
                // 如果key相同则覆盖value值
                if ((k = e.key) == key ||
                    (e.hash == hash && key.equals(k))) {
                    oldValue = e.value;
                    if (!onlyIfAbsent) {
                        e.value = value;
                        ++modCount;
                    }
                    break;
                }
                // 指向下一个槽，能一直循环的条件
                e = e.next;
            }
            // 若果这个key要存入的槽无节点（链表为空）
            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;
            }
        }
    } finally {
        // 释放锁
        unlock();
    }
    return oldValue;
}

——————————————————————————————————————————————————————————————————————