ConcurrentHashMapのを理解するために

ConcurrentHashMapのはjdk1.8は、セグメント化されたロックのアイデアである前に採用しました。

final Segment<K,V>[] segments;

このセグメントはReetrantLockのリエントラントロックを継承しました。セグメントはHashEntry配列を維持するために、ハッシュテーブル、セグメントのサブセットです。そして、パラメータが16の値が、それは、それは16個の要素のセグメントを示しているときときConcurrentLeve、で、最大16件の同時実行スレッドがあります。

セグメント内の各要素は、HashEntryの配列を維持します

transient volatile HashEntry<K,V>[] table;

これは、静的な内部クラスです。

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

同様に、我々は、セグメントのデータ構造を見て

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

私たちは、コンストラクタを見て：

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を使用する場合、初期化方法は、3つのパラメータを有しています。

上記のコードからわかるように、アレイssizeのセグメントサイズはconcurrentLevelが、必ずしもそうではないが等しいconcurrentLevelによって決まる、ssize 2 concurrentLevelの最小パワー以上でなければなりません。例えば：デフォルトconcurrentLevel 16、ssizeの16によって、concurrentLevel場合14、16 ssize; concurrentLevel 17、ssizeの32ます。なぜ配列のセグメントサイズは2の累乗でなければなりませんか？実際には、キーはインデックスのセグメントを見つけるためにビットのハッシュアルゴリズムによって押しやすいです。

segmentShiftとsegmentMaskについて

主な役割segmentShift segmentMaskグローバル変数とセグメントの位置を特定するために使用される、int型J =（ハッシュ>>> segmentShift）＆segmentMask。
segmentMask：セグメントマスク、アレイ16個のセグメントの長さは、セグメントマスクは16-1 = 15である場合、長さ32のセグメント、セグメント= 31 32-1のマスク。すべてのこのようにして得られたビット位置より良いハッシュの均一性を確保することができ、1
segmentShiftを：sshift電源2 ssize、segmentShift = 32 sshiftに等しいです。セグメント16の長さであれば、segmentShift = 32-4 = 28、セグメント32の長さであれば、segmentShift = 32-5 = 27。32ビットの符号なし右シフトsegmentShiftの最大の計算されたハッシュ値は、それがわずか数高い保持率が（残りのビットは役に立たない）、次いでマスクセグメントがsegmentMaskビット単位のセグメントを配置することを意味します。

置く方法：

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

計算INT jの後=（ハッシュ>>> segmentShift） ＆segmentMask、 インデックスへのアクセスには、セグメントに割り当てられているS = ensureSegment（j）は、ロックを見つけます。
次に挿入します。
その後、我々は見て

セグメントのputメソッド：

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
 HashEntry<K,V> node = tryLock() ? null :
        scanAndLockForPut(key, hash, value);
        //tryLock不成功时会遍历定位到的HashEnry位置的链表（遍历主要是为了使CPU缓存链表），若找不到，则创建HashEntry。tryLock一定次数后（MAX_SCAN_RETRIES变量决定），则lock。若遍历过程中，由于其他线程的操作导致链表头结点变化，则需要重新遍历。
    V oldValue;
    try {
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash;
        //定位HashEntry，可以看到，这个hash值在定位Segment时和在Segment中定位HashEntry都会用到，只不过定位Segment时只用到高几位。
        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;
　　　　　　　　　　　　　　//若c超出阈值threshold，需要扩容并rehash。扩容后的容量是当前容量的2倍。这样可以最大程度避免之前散列好的entry重新散列，具体在另一篇文章中有详细分析，不赘述。扩容并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;
}

方法を取得します：

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