ConcurrentHashMap源码及分析

　　ConcurrentHashMap是在jdk1.5版本开始，存在于java.util.concurrent包下。本文主要是针对jdk1.7版本。

　　由于HashMap是非线程安全的，HashTable虽然是线程安全的，但是它的实现是对整个哈希表加锁，这样的话，效率很低下。

ConcurrentHashMap是线程安全的实现，像是对HashTable做的优化，但是它使用的是分段锁机制。ConcurrentHashMap的底层

也是使用基于数组+链表的数据结构。具体结构如下代码所示：

/**
 * The segments, each of which is a specialized hash table.
 */
final Segment<K,V>[] segments;  
内部使用的是Segment类型的数组结构，Segment是它的一个内部类，继承了ReentrantLock，表明数组中每个不同域Segment是加锁
的，互不影响。Segment的内部结构也是基于数组+链表的，具体代码是：

/**
 * The per-segment table. Elements are accessed via
 * entryAt/setEntryAt providing volatile semantics.
 */
transient volatile HashEntry<K,V>[] table;

内部使用的是HashEntry类型的数组，HashEntry就是内部存储的链表结构元素，它的具体实现如下：

final int hash;
final K key;
volatile V value;
volatile HashEntry<K,V> next;

　　上面我们介绍了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);
    return s.put(key, hash, value, false);
}
从源码看出，ConcurrentHashMap是不允许放入null的key和value，它是先根据key的hash值，再hash算法找到具体要放入哪个Segment。
ensureSegment方法是根据存入的键值对是否进行扩容。之后调用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;
}

从源码看出get取值是根据Key的hash及再hash算法找到具体的Segment。之后进行遍历，找出对应的value。此方法是没有进行加锁。

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) {
                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（最多尝试3次），若不正确，则进行所有Segmeng加锁进行统计大小。

本文只是对ConcurrentHashMap的结构和几个重要的方法做了简要分析，具体详情请看源码。