ConcurrentHashMap源码解析（JDK1.7）

• HashMap ：线程不安全，在并发环境下，可能会形成环状链表，导致get操作时，CPU空转，所以，在并发环境中使用HashMap是非常危险的。

• HashTable ： HashTable和HashMap的实现原理几乎一样

  差别：

  • 1.HashTable不允许key和value为null；
  • 2.HashTable是线程安全的。

• ConcurrentHashMap：底层数据结构为数组+数组+链表形式实现，Segment（分段锁）类似于HashMap的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表，同时又是一个ReentrantLock（重入锁）（Segment继承了ReentrantLock）

分段锁：将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，能够实现真正的并发访问。

• 优点：写操作时可以只对元素所在的Segment进行加锁即可，不会影响到其他的Segment，这样，在最理想的情况下，ConcurrentHashMap可以最高同时支持Segment数量大小的写操作
• 缺点：Hash的过程要比HashMap长

成员变量：

     //默认初始容量
     static final int DEFAULT_INITIAL_CAPACITY = 16; 
     //默认加载因子(针对Segment数组中的某个Segment中的HashEntry数组扩容) 
     static final float DEFAULT_LOAD_FACTOR = 0.75f; 
     //默认Segment数组的大小，也成为并发量 
     static final int DEFAULT_CONCURRENCY_LEVEL = 16; 
     //最大容量 
     static final int MAXIMUM_CAPACITY = 1 << 30; 
     //一个Segment的HashEntry数组的最小容量 
     static final int MIN_SEGMENT_TABLE_CAPACITY = 2; 
     //一个Segment的HashEntry数组的最大容量 
     static final int MAX_SEGMENTS = 1 << 16; 
     
     static final int RETRIES_BEFORE_LOCK = 2; 

put方法：

public V put(K key, V value) { Segment<K,V> s; 
	//判断value是否为null,如果为null则抛出空指针异常 
	if (value == null) 
		throw new NullPointerException(); 
	//计算key的hash值 
	int hash = hash(key); 
	//根据key的hash值计算出在Segment数组中的位置j  
	int j = (hash >>> segmentShift) & segmentMask; 
	//判断该位置是否为null， 
	if ((s = (Segment<K,V>)UNSAFE.getObject
		(segments, (j << SSHIFT) + SBASE)) == null)
	//如果为null，初始化该位置segment[j]，通过ensureSegment(j) s = ensureSegment(j); 
	//调用Segment的put方法将数据插入到HashEntry中
	return s.put(key, hash, value, false); 
}

关键步骤：

private Segment<K,V> ensureSegment(int k) {
		//获取到当前的Segment数组
        final Segment<K,V>[] ss = this.segments;
        long u = (k << SSHIFT) + SBASE; // raw offset
        Segment<K,V> seg;
        //判断当前分段是否已经被其他线程初始化了
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
            Segment<K,V> proto = ss[0]; // use segment 0 as prototype
            int cap = proto.table.length;
            float lf = proto.loadFactor;
            int threshold = (int)(cap * lf);
            //初始化segment[k]内部的HashEntry数组
            HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
            if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                == null) { // recheck
                Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
                // 使用 while 循环，内部用 CAS，当前线程成功设值或其他线程成功设值后，退出
                while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                       == null) {
                    if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                        break;
                }
            }
        }
        return seg;
    }

扩容方法：

put的时候，如果判断该值的插入会导致segment中的元素个数超过阈值，那么先会进行扩容，再插值。

        private void rehash(HashEntry<K,V> node) {
            HashEntry<K,V>[] oldTable = table;
            int oldCapacity = oldTable.length;
            //新的容量为旧的容量的2倍
            int newCapacity = oldCapacity << 1;
            //计算新的扩容阈值
            threshold = (int)(newCapacity * loadFactor);
            //创建新数组
            HashEntry<K,V>[] newTable =
                (HashEntry<K,V>[]) new HashEntry[newCapacity];
            int sizeMask = newCapacity - 1;
            //遍历数组，将原数组位置i处的链表拆分到新数组位置
            for (int i = 0; i < oldCapacity ; i++) {
            //e为链表的第一个元素
                HashEntry<K,V> e = oldTable[i];
                if (e != null) {
                //如果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;
                        //找到第一个后续节点新的index不变的节点
                        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
                        // 第一个后续节点新index不变节点前的所有节点都需要重新创建分配
                        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);
                        }
                    }
                }
            }
            //将新来的node放到新数组中刚刚的两个链表之一的头部
            int nodeIndex = node.hash & sizeMask; // add the new node
            node.setNext(newTable[nodeIndex]);
            newTable[nodeIndex] = node;
            table = newTable;
        }

get方法

public V get(Object key) {
        Segment<K,V> s; // manually integrate access methods to reduce overhead
        HashEntry<K,V>[] tab;
        //计算key的hash
        int h = hash(key);
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        //根据key的hash找到对应的segment的位置，并判断segment中的HashEntry数组是否为nul
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
            (tab = s.table) != null) {
            //对segment中的数组的每个链表进行遍历
            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过程并没有加锁，添加节点的操作put和删除节点的操作remove都是加上segment上的独占锁的。