Java-Concurrent框架--ConcurrentHashMap源码解析（JDK1.7）

在Map的实现类中除了HashMap和HashTable以外还有一个ConcurrentHashMap。HashMap和HashTable一都非常熟悉，HashTable是线程安全的、且不能存储Null值，HashMap是非线程安全的、可以存储Null值。

ConcurrentHashMap是java.util.concurrent包中的类，他是结合HashMap和HashTable而来的Map实现类。从名字就知道是一种线程安全的Map类，那他和线程安全的HashTable有什么区别，往下看就知道了。

一 内部结构

在介绍ConcurrentHashMap内部结构之前，先复习下HashTable，就知道ConcurrentHashMap内部结构的设计原理了

1.1 HashTable

先看一下HashTable主要方法的方法定义：

public synchronized int size()
public synchronized boolean isEmpty()
public synchronized V get(Object key)
public synchronized V put(K key, V value)

通过上面的方法定义，可以知道HashTable之所以能够保证线程安全，是因为基本上HashTable所有的方法都通过synchronized进行了锁保护，而且是将整个HashTable对象加锁，也就是同时只能有一个线程访问、修改HashTable。这样带来的问题就是在多线程环境中代价大、效率低。

1.2 ConcurrentHashMap

HashTable效率低速度慢的原因就在于每次都要将整个HashTable锁起来，ConcurrentHashMap正是巧妙的解决了这个问题，每次只将要被修改的局部地方加上锁，其他地方还可以访问和修改。

ConcurrentHashMap的内部结构通过两个内部类实现：Segment类和HashEntry类。

每个ConcurrentHashMap对象所有数据都是存在Segment< K,V>[] segments数组里，数组的每个元素都是一个Segment对象；Segment类的主要数据结构是HashEntry< K,V>[] table数组，table数组中的HashEntry是一个链表，链表的每个结点存储一个键值对。ConcurrentHashMap中每一个键值对最终就是存储在这里。

所以说ConcurrentHashMap中主要实体类就是三个：ConcurrentHashMap（整个Hash表）,Segment（桶），HashEntry（节点）。

然后每次只对segments数组中的一个Segment对象加锁，这样segments数组中跟其他Segment对象就可以被正常访问了。所以说ConcurrentHashMap是HashMap和HashTable的结合。

ConcurrentHashMap就是通过这种局部加锁的方式提高并发访问的速度。下图就是两种Map实现类的结构对比。

二 类关系图

ConcurrentHashMap类位于java.util.concurrent包当中，实现了ConcurrentMap接口，继承了AbstractMap。

然后我们再看看ConcurrentHashMap内部类Segment的类关系图，可以发现Segment继承了Reentrantlock类，正是他完成了多线程的同步控制

三 ConcurrentHashMap类定义

我们从主要成员变量、构造函数、常用API三个方面了解ConcurrentHashMap的定义

3.1 主要成员变量

上面第一节讲了ConcurrentHashMap有两个重要的内部类Segment类和HashEntry类，下面我们就看看他们的源码

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
        implements ConcurrentMap<K, V>, Serializable {

    final Segment<K,V>[] segments;

    static final class Segment<K,V> extends ReentrantLock implements Serializable {
        transient int count;  //用于记录每个Segment桶中键值对的个数
        transient int modCount;  //对table的大小造成影响的操作的数量（比如put或者remove操作）
        transient int threshold;  //阈值，Segment里面元素的数量超过这个值依旧就会对Segment进行扩容
        transient volatile HashEntry<K,V>[] table;  //链表数组，数组中的每一个元素代表了一个链表的头部
        final float loadFactor;  //负载因子，用于确定threshold，默认是1
    }

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

可以看出来Segment是个锁对象，HashEntry是链表的一个结点，HashEntry.Key存的是每个键值对的键值，HashEntry.Value存的键值对的值。而且大多数变量都是final修饰的。

3.2 构造函数

ConcurrentHashMap一共有五个构造函数，我们重点分析下面第一个就行，其他三个都是这个构造函数实现的。最后一个构造函数相当于是复制一个新的对象。

• public ConcurrentHashMap(int ,float , int)
• public ConcurrentHashMap(int ,float)
• public ConcurrentHashMap(int)
• public ConcurrentHashMap()
• public ConcurrentHashMap(Map

public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        // initialCapacity是Map中键值对初始个数
        // loadFactor是负载参数
        // concurrentLevel代表ConcurrentHashMap内部的Segment的数量
        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;
        }
        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; // table[]数组大小
        // 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);
        this.segments = ss;
    }

在初始化过程中涉及几个关键的量，我们先看构造函数的三个参数：

• initialCapacity：ConcurrentHashMap中键值对总个数，如果不指定是默认取16
• loadFactor：负载参数，用于确定table[]数组扩容阈值，就是当table[ ]数组长度大于(cap * loadFactor)时，进行扩容，未指定是默认取0.75
• concurrencyLevel：代表ConcurrentHashMap内部的segment[ ]数组的长度，concurrencyLevel在初始化后是不可改变的，也就是说segment[ ]数组长度是不可变得，所以扩容操作主要针对于table[ ]数组。这样的好处在于扩容是不需要对整个ConcurrentHashMap做rehash，只对某个table[ ]数组做rehash即可。未指定是默认取16

构造函数主要功能就是创建了sagment[ ]数组和table[ ]数组，而重点就在于计算这两个数组的大小。

• ssize：sagment[ ]数组的真实大小，sszie是不大于concurrencyLevel的最大的2的指数，他的好处在于方便采用移位操作进行hash，加快速度
• cap：table[ ]数组的大小，cap是不大于initialCapacity / ssize的最大的2的指数，好处同样也是加快hash

另外还有两个重要的变量segmentShift和segmentMask：

• segmentShift
• segmentMask

这两个量是用来定位segment桶在segments[]数组中位置用的，详见“4.1定位sagment桶”

3.3 常用API

• public ConcurrentHashMap(int initialCapacity，float loadFactor, int concurrencyLevel) 构造函数
• public boolean isEmpty( )
• public int size()
• public V get(Object key)
• public boolean containsKey(Object key)
• public boolean containsValue(Object value)
• public V put(K key, V value)
• public V remove(Object key)
• public void clear()
• public Set< K> keySet()

四 常用方法源码分析

4.1 定位sagment桶

在ConcurrentHashMap的增删改查操作中有一个步骤至关重要，就是要先通过key值确定键值对究竟是存在segments[ ]数组中哪个位置，table[ ]数组中哪个位置。

    private Segment<K,V> segmentForHash(int h) {
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        return (Segment<K,V>) UNSAFE.getObjectVolatile(segments, u);
    }

参数h就是hash值，根据传入的hash值向右无符号右移segmentShift位，然后和segmentMask进行与操作，这里的segmentShift和segmentMask值是在构造函数中计算得到的，就可以得出以下结论：假设Segment的数量是2的n次方，根据元素的hash值的高n位就可以确定元素到底在哪一个Segment中。

这里有两个地方我一直还没搞懂，一是“>>> segmentShift”操作和“& segmentMask”感觉是重复的，不知道为什么要这样，多一次计算确保正确？二是后面的“<< SSHIFT) + SBASE”一直还没搞明白是在干啥。。。

计算table[]数组中的位置通过int index = (table.length - 1) & hash;实现。

4.2 put（）

    // ConcurrentHashMap类的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);
        // 调用Segment类的put方法
        return s.put(key, hash, value, false);  
    }

    // Segment类的put（）方法
    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;
                // 根据hash计算在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;
                        // 判断table[]是否需要扩容，并通过rehash()函数完成扩容
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

可以发现put的基本过程就是，通过hash值确定segments[]中segment桶的位置，然后调用Segment的put方法将键值对插入segment桶的table[]数组中，先确定table[]数组是否存在该key值和对应的位置，再插入到具体的链表位置。

有以下几点值得关注：

• 同步锁：多线程同步锁是在调用Segment类的put方式时使用的，此时其他线程不能访问当前segment桶，但是可以其他segment桶
• 扩容：在添加新的键值对之前会判断当前segment桶大小是否超过阈值threshold ，如果超过就调用rehash（）进行扩容，newCapacity = oldCapacity << 1;将table[]大小扩容到原来的两倍

4.3 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;
    }

get( )方法的实现过程比较简单，首先计算hash值并确定segment桶，然后确定table[]数组中HashEntry的位置，遍历HashEntry链表，获取Value值

4.4 remove( )

    // ConcurrentHashMap类的remove方法
    public V remove(Object key) {
        int hash = hash(key);
        // 获取segment桶
        Segment<K,V> s = segmentForHash(hash);  
        // 调用Segment类的remove方法
        return s == null ? null : s.remove(key, hash, null);
    }

    Segment类的remove方法
    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;
        }

理解了put( )和get( )操作后，删除操作也就自然理解了。

之前有的版本的JDK中，HashEntry类的实现中next的声明为：final HashEntry

4.5 size( )

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;
        int size;
        boolean overflow; // true if size overflows 32 bits
        long sum;         // sum of modCounts
        long last = 0L;   // previous sum
        int retries = -1; // first iteration isn't retry
        try {
            for (;;) {
                if (retries++ == RETRIES_BEFORE_LOCK) {
                    // 给所有的segment桶加锁
                    for (int j = 0; j < segments.length; ++j)
                        ensureSegment(j).lock(); // force creation
                }
                sum = 0L;
                size = 0;
                overflow = false;
                for (int j = 0; j < segments.length; ++j) {
                    Segment<K,V> seg = segmentAt(segments, j);
                    if (seg != null) {
                        sum += seg.modCount;
                        int c = seg.count;
                        if (c < 0 || (size += c) < 0)
                            overflow = true;
                    }
                }
                if (sum == last)
                    break;
                last = sum;
            }
        } finally {
            if (retries > RETRIES_BEFORE_LOCK) {
                for (int j = 0; j < segments.length; ++j)
                    segmentAt(segments, j).unlock();
            }
        }
        return overflow ? Integer.MAX_VALUE : size;
    }

可以发现size( )方法很不一样：

• size( )方法会将整个ConcurrentHashMap遍历一次，来获得map大小
• 遍历之前会将ConcurrentHashMap中每个segment桶都加锁

五 总结

ConcurrentHashMap是结合HashTable和HashMap得到的线程安全的保证高并发的Map实现类

• ConcurrentHashMap主要结构是一个Segment[]数组，每个Segment元素都有一个HashEntry[]数组，Segment相当于一个小的HashTable
• Segment[]数组大小是不可变的，扩容操作是将Segment类中HashEntry[]扩容到原来的两倍
• put( )和remove( )方法是要加锁的，而且只对单个segment桶加锁
• size( )需要遍历整个ConcurrentHashMap，而且每个segment桶都要加锁

---

参考资料：
http://www.iteye.com/topic/1103980
http://www.cnblogs.com/ITtangtang/p/3948786.html