ConcurrentHashMap部分源码分析 JDK1.7版

ConcurrentHashMap 1.7采用了非常精妙的"分段锁"策略，ConcurrentHashMap的主干是个Segment数组。

final Segment<K,V>[] segments;

Segment继承了ReentrantLock，所以它就是一种可重入锁。在ConcurrentHashMap，一个Segment就是一个子哈希表，Segment里维护了一个HashEntry数组，并发环境下，对于不同Segment的数据进行操作是不用考虑锁竞争的。所以，对于同一个Segment的操作才需考虑线程同步，不同的Segment则无需考虑。
结构是：一个ConcurrentHashMap有一个Segment数组。每一个Segment中有一个HashMap。

HashEntry

 static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry<K,V> next;
        //其他省略
} 

Segment构造方法

Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
            this.loadFactor = lf;//负载因子
            this.threshold = threshold;//阈值
            this.table = tab;//主干数组即HashEntry数组
        }

ConcurrentHashMap构造方法

public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {
            if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
                throw new IllegalArgumentException();
            //MAX_SEGMENTS 为1<<16=65536，也就是最大并发数为65536
            if (concurrencyLevel > MAX_SEGMENTS)
                concurrencyLevel = MAX_SEGMENTS;
            //2的sshif次方等于ssize，例:ssize=16,sshift=4;ssize=32,sshif=5
           int sshift = 0;
          //ssize 为segments数组长度，根据concurrentLevel计算得出
          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;
          //计算cap的大小，即Segment中HashEntry的数组长度，cap也一定为2的n次方.
          int c = initialCapacity / ssize;
          if (c * ssize < initialCapacity)
              ++c;
          int cap = MIN_SEGMENT_TABLE_CAPACITY;
          while (cap < c)
              cap <<= 1;
          //创建segments数组并初始化第一个Segment，其余的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); 
          this.segments = ss;
     }

初始化方法有三个参数，如果用户不指定则会使用默认值，initialCapacity为16，loadFactor为0.75（负载因子，扩容时需要参考），concurrentLevel为16。从上面的代码可以看出来,Segment数组的大小ssize是concurrentLevel来决定的，但是却不一定等于concurrentLevel，ssize一定是大于或等于concurrentLevel的最小的2的次幂。比如：默认情况下concurrentLevel是16，则ssize为16；若concurrentLevel为14，ssize为16；若concurrentLevel为17，则ssize为32。为什么Segment的数组大小一定是2的次幂？其实主要是便于通过按位与的散列算法来定位Segment的index。

put方法

public V put(K key, V value) {
        Segment<K,V> s;
        //concurrentHashMap不允许key/value为空
        if (value == null)
            throw new NullPointerException();
        //hash函数对key的hashCode重新散列，避免差劲的不合理的hashcode，保证散列均匀
        int hash = hash(key);
        //返回的hash值无符号右移segmentShift位与段掩码进行位运算，定位segment
        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);
    }

逻辑比较简单；1.定位segment并确保定位的Segment已初始化 2.调用Segment的put方法。

由于Segment的初始化是惰性加载，只初始化Segment[0.]这个元素。当ConcurrentHashMap初始化的时候，会将Segment的相关信息都放在Segment[0]这个元素里面。(因为初始化Segment也要初始化它“管理”的hashmap,想加载因子，数组长度这些属性。)所以当put方法执行去比对hashcode时发现找到的这个Segment没有初始化，就会触发该Segment的初始化，那Segment里面的属性就去Segment[0]里面去找。将初始化完成后再去执行值的添加。
在往Segment和Entry数组里放元素时保证线程安全的关键是执行了UNSAFE和CAS这种线程安全的方法。在put值的时候会获取对应的Segment锁。

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，再定位HashEntry，进而开始遍历
        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方法无需加锁，由于其中涉及到的共享变量都使用volatile修饰，volatile可以保证内存可见性，所以不会读取到过期数据。