ConcurrentHashMap

ConcurrentHashMap

ConcurrentHashMap是一个线程安全的Hash Table，它的主要功能是提供了一组和

HashTable功能相同但是线程安全的方法。ConcurrentHashMap可以做到读取数据不加

锁，并且其内部的结构可以让其在进行写操作的时候能够将锁的粒度保持地尽量地小，不

用对整个ConcurrentHashMap加锁。

ConcurrentHashMap的内部结构

ConcurrentHashMap为了提高本身的并发能力，在内部采用了一个叫做Segment的结构，

一个Segment其实就是一个类Hash Table的结构，Segment内部维护了一个链表数组，我

们用下面这一幅图来看下ConcurrentHashMap的内部结构：

从上面的结构我们可以了解到，ConcurrentHashMap定位一个元素的过程需要进行两次

Hash操作，第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部，因

此，这一种结构的带来的副作用是Hash的过程要比普通的HashMap要长，但是带来的好处

是写操作的时候可以只对元素所在的Segment进行加锁即可，不会影响到其他的

Segment，这样，在最理想的情况下，ConcurrentHashMap可以最高同时支持Segment数

量大小的写操作（刚好这些写操作都非常平均地分布在所有的Segment上），所以，通过

这一种结构，ConcurrentHashMap的并发能力可以大大的提高。

Segment

我们再来具体了解一下Segment的数据结构：

  

static  final   class  Segment<K,V>   extends  ReentrantLock   implements Serializable {
助
transient  volatile   int  count;
transient  int   modCount;
transient  int   threshold;
transient  volatile   HashEntry<K,V>[]   table;
final  float   loadFactor;
}

详细解释一下Segment里面的成员变量的意义：

count：Segment中元素的数量

modCount：对table的大小造成影响的操作的数量（比如put或者remove操作）

threshold：阈值，Segment里面元素的数量超过这个值依旧就会对Segment进行扩容

table：链表数组，数组中的每一个元素代表了一个链表的头部

loadFactor：负载因子，用于确定threshold

HashEntry

Segment中的元素是以HashEntry的形式存放在链表数组中的，看一下HashEntry的结构：

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

可以看到HashEntry的一个特点，除了value以外，其他的几个变量都是final的，这样做是

为了防止链表结构被破坏，出现ConcurrentModification的情况。

ConcurrentHashMap的初始化

下面我们来结合源代码来具体分析一下ConcurrentHashMap的实现，先看下初始化方法：

  

  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;
        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;
        // 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.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
    }

CurrentHashMap的初始化一共有三个参数，一个initialCapacity，表示初始的容量，一个

loadFactor，表示负载参数，最后一个是concurrentLevel，代表ConcurrentHashMap内部

的Segment的数量，ConcurrentLevel一经指定，不可改变，后续如果ConcurrentHashMap

的元素数量增加导致ConrruentHashMap需要扩容，ConcurrentHashMap不会增加

Segment的数量，而只会增加Segment中链表数组的容量大小，这样的好处是扩容过程不

需要对整个ConcurrentHashMap做rehash，而只需要对Segment里面的元素做一次rehash

就可以了。

整个ConcurrentHashMap的初始化方法还是非常简单的，先是根据concurrentLevel来new

出Segment，这里Segment的数量是不大于concurrentLevel的最大的2的指数，就是说

Segment的数量永远是2的指数个，这样的好处是方便采用移位操作来进行hash，加快

hash的过程。接下来就是根据intialCapacity确定Segment的容量的大小，每一个Segment

的容量大小也是2的指数，同样使为了加快hash的过程。

这边需要特别注意一下两个变量，分别是segmentShift和segmentMask，这两个变量在后

面将会起到很大的作用，假设构造函数确定了Segment的数量是2的n次方，那么

segmentShift就等于32减去n，而segmentMask就等于2的n次方减一。

ConcurrentHashMap的get操作

  

 

前面提到过ConcurrentHashMap的get操作是不用加锁的，我们这里看一下其实现：

这个函数用了位操作来确定Segment，根据传入的hash值向右无符号右移segmentShift

位，然后和segmentMask进行与操作，结合我们之前说的segmentShift和segmentMask的

值，就可以得出以下结论：假设Segment的数量是2的n次方，根据元素的hash值的高n位

就可以确定元素到底在哪一个Segment中。

在确定了需要在哪一个segment中进行操作以后，接下来的事情就是调用对应的Segment

的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);
        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) {
                K k;
                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                    return e.value;
            }
        }
        return null;
    }

transient  volatile   int  count;

可以看到count是volatile的，实际上这里里面利用了volatile的语义：

对volatile字段的写入操作happens-before于每一个后续的同一个字段的读操

作。

因为实际上put、remove等操作也会更新count的值，所以当竞争发生的时候，volatile的语

义可以保证写操作在读操作之前，也就保证了写操作对后续的读操作都是可见的，这样后

面get的后续操作就可以拿到完整的元素内容。

  

put()方法：

public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        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);
    }

 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;
                        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;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

首先对Segment的put操作是加锁完成的，如果Segment中元素的数量超过

了阈值（由构造函数中的loadFactor算出）这需要进行对Segment扩容，并且要进行

rehash，关于rehash的过程大家可以自己去了解，这里不详细讲了。

getFirst的过程，确定链表头部的位置。

这里的这个循环是在链表中寻找和要put的元素相同key的元素，如果找到，就

直接更新更新key的value，如果没有找到，生成一个新的HashEntry并且

把它加到整个Segment的头部，然后再更新count的值。

Remove操作的前面一部分和前面的get和put操作一样，都是定位Segment的过程，然后再

调用Segment的remove方法

 public V remove(Object key) {
        int hash = hash(key);
        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;
        }

首先remove操作也是确定需要删除的元素的位置，不过这里删除元素的方法不是简单地把

待删除元素的前面的一个元素的next指向后面一个就完事了，我们之前已经说过HashEntry

中的next是final的，一经赋值以后就不可修改，在定位到待删除元素的位置以后，程序就

将待删除元素前面的那一些元素全部复制一遍，然后再一个一个重新接到链表上去

ConcurrentHashMap的size操作

在前面的章节中，我们涉及到的操作都是在单个Segment中进行的，但是

ConcurrentHashMap有一些操作是在多个Segment中进行，比如size操作，

ConcurrentHashMap的size操作也采用了一种比较巧的方式，来尽量避免对所有的

Segment都加锁。

前面我们提到了一个Segment中的有一个modCount变量，代表的是对Segment中元素的数

量造成影响的操作的次数，这个值只增不减，size操作就是遍历了两次Segment，每次记录

Segment的modCount值，然后将两次的modCount进行比较，如果相同，则表示期间没有

发生过写入操作，就将原先遍历的结果返回，如果不相同，则把这个过程再重复做一次，

如果再不相同，则就需要将所有的Segment都锁住，然后一个一个遍历了