ConcurrentHashMap

一、结构解析

ConcurrentHashMap和Hashtable主要区别就是围绕着锁的粒度以及如何锁,可以简单理解成把一个大的HashTable分解成多个，形成了锁分离。如图:

而Hashtable的实现方式是—锁整个hash表

二、应用场景

当有一个大数组时需要在多个线程共享时就可以考虑是否把它给分层多个节点了，避免大锁。并可以考虑通过hash算法进行一些模块定位。

其实不止用于线程，当设计数据表的事务时（事务某种意义上也是同步机制的体现），可以把一个表看成一个需要同步的数组，如果操作的表数据太多时就可以考虑事务分离了（这也是为什么要避免大表的出现），比如把数据进行字段拆分，水平分表等.

三、源码解读

ConcurrentHashMap中主要实体类就是三个：ConcurrentHashMap（整个Hash表）,Segment（桶），HashEntry（节点），对应上面的图可以看出之间的关系。
初始化：

public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
        /*Max_SEGMENTS最大为 1 << 16，即最大并发数65536*/
    if (concurrencyLevel > MAX_SEGMENTS)   
        concurrencyLevel = MAX_SEGMENTS;
    // Find power-of-two sizes best matching arguments
        /*2的sshift次方=ssize*/    
    /*往下可以看到ssize为segment数组的大小，和concurrentLevel直接相关*/
    int sshift = 0;   
    int ssize = 1;    
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
        /*segmentShift(段偏移量)和segmentMask(段掩码)用于定位Segment*/
    this.segmentShift = 32 - sshift;   
    this.segmentMask = ssize - 1;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    /*往下看可以发现，cap代表HashEntry数组的大小*/
    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;
}

initialCapacity、loadFactor、concurrencyLevel若开发者未指定的话则取默认值

static final int DEFAULT_INITIAL_CAPACITY = 16;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int DEFAULT_CONCURRENCY_LEVEL = 16;

put操作

public V put(K key, V value) {
    Segment<K,V> s;
     /*ConcurrentHashMap的key和value均不能为空*/  
    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);
}
put方法主要包含两步:定位Segment、调用segment的put方法插入元素

get()

public V get(Object key) {
    Segment<K,V> s; 
    HashEntry<K,V>[] tab;
    int h = hash(key);
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    /*先定位到Segment*/
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        /*再便遍历segment中的HashEntry数组*/
        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;
}

rehash()

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    /*扩容为原来HashEntry数组的两倍*/
    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;
            if (next == null)   //  Single node on list
                newTable[idx] = e;
            else { // Reuse consecutive sequence at same slot
                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;
                // Clone remaining nodes
                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;

可以看到，HashEntry扩容为原来的两倍，扩容时不时针对整个ConcurrentHashMap，而是只对需要扩容的那个Segment进行扩容（所以高效)
ConcurrentHashMap的get操作是非常高效的，原因在于get操作不需要加锁。get方法里面使用到的共享变量都是volatile类型的，这些个变量能够在线程间保持可见性，能被多个线程同时读但是又能保证只被单线程写，并且不会读取到过期值。这样的变量就是HashEntry

transient volatile HashEntry<K,V>[] table;  //Segment里的~
volatile HashEntry<K,V> next;  //HashEntry链表中的~

使用volatile变量修饰后不会读取到过期值，是由于在java内存模型中的happen-before原则决定的，volatile修饰字段的写入操作总是优先于读操作，即使多个线程同时修改volatile变量字段，get字段也总能保证获取到最新的值（volatile变量相对于锁的优势体现出来了）。