Java集合类（十六）JUC中的集合--ConcurrentHashMap jdk1.7_concurrenthashmap有列表吗

一、ConcurrentHashMap介绍

ConcurrentHashMap是线程安全的哈希表，它是通过“锁分段”来保证线程安全。ConcurrentHashMap将哈希表分成许多片段(Segment)，每一个片段除了保存哈希表之外，本质上也是一个“可重入的互斥锁”(ReentrantLock)。多线程对同一个片段的访问，是互斥的；但是，对于不同片段的访问，却是可以同步进行的。

二、ConcurrentHashMap原理和数据结构

如下图为concurrentHashMap的类图

• ConcurrentHashMap继承于AbstractMap抽象类。
• Segment是ConcurrentHashMap中的内部类，它就是ConcurrentHashMap中的“锁分段”对应的存储结构。ConcurrentHashMap与Segment是组合关系，1个ConcurrentHashMap对象包含若干个Segment对象。在代码中，这表现为ConcurrentHashMap类中存在“Segment数组”成员。
• Segment类继承于ReentrantLock类，所以Segment本质上是一个可重入的互斥锁。

• HashEntry也是ConcurrentHashMap的内部类，是单向链表节点，存储着key-value键值对。Segment与HashEntry是组合关系，Segment类中存在“HashEntry数组”成员，“HashEntry数组”中的每个HashEntry就是一个单向链表。

  对于多线程访问对一个“哈希表对象”竞争资源，Hashtable是通过一把锁来控制并发；而ConcurrentHashMap则是将哈希表分成许多片段，对于每一个片段分别通过一个互斥锁来控制并发。ConcurrentHashMap对并发的控制更加细腻，它也更加适应于高并发场景！

三、锁分段简介

什么是分段锁 ?
一个ConcurrentHashMap包含一个 Segement[]数组，
这个数组其中一个Segement对象中又包含一个HashEntry[]数组，每个HashEntry对象代表一个链表结构。其实每个Segment对象只是对整个Hash表的一部分做了特定的包装而已。

Segment本身就是ReentrantLock的子类（也就是一把重入锁），当访问某个数据时只需要锁住这个数据所在的Segement内组合的HashEntry[]数组即可，在其他Segment中的数据依旧可以正常访问。

也就是说，ConcurrentHashMap中，将原本一个大的Hash表（hash桶，也就是全部的HashEntry[]数组），分成n份，每一份都组合到一个Segment对象中，并且每一份使用这一份对应的Segment锁保护。在最大程度上隔离了数据，并且把隔离的数据用Segment锁保护，达到不同线程互斥的访问。
如图为concurrentHashMap的内部结构：

四、ConcurrentHashMap函数列表

// 创建一个带有默认初始容量 (16)、加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap()
// 创建一个带有指定初始容量、默认加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap(int initialCapacity)
// 创建一个带有指定初始容量、加载因子和默认 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor)
// 创建一个带有指定初始容量、加载因子和并发级别的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
// 构造一个与给定映射具有相同映射关系的新映射。
ConcurrentHashMap(Map<? extends K,? extends V> m)

// 从该映射中移除所有映射关系
void clear()
// 一种遗留方法，测试此表中是否有一些与指定值存在映射关系的键。
boolean contains(Object value)
// 测试指定对象是否为此表中的键。
boolean containsKey(Object key)
// 如果此映射将一个或多个键映射到指定值，则返回 true。
boolean containsValue(Object value)
// 返回此表中值的枚举。
Enumeration<V> elements()
// 返回此映射所包含的映射关系的 Set 视图。
Set<Map.Entry<K,V>> entrySet()
// 返回指定键所映射到的值，如果此映射不包含该键的映射关系，则返回 null。
V get(Object key)
// 如果此映射不包含键-值映射关系，则返回 true。
boolean isEmpty()
// 返回此表中键的枚举。
Enumeration<K> keys()
// 返回此映射中包含的键的 Set 视图。
Set<K> keySet()
// 将指定键映射到此表中的指定值。
V put(K key, V value)
// 将指定映射中所有映射关系复制到此映射中。
void putAll(Map<? extends K,? extends V> m)
// 如果指定键已经不再与某个值相关联，则将它与给定值关联。
V putIfAbsent(K key, V value)
// 从此映射中移除键（及其相应的值）。
V remove(Object key)
// 只有目前将键的条目映射到给定值时，才移除该键的条目。
boolean remove(Object key, Object value)
// 只有目前将键的条目映射到某一值时，才替换该键的条目。
V replace(K key, V value)
// 只有目前将键的条目映射到给定值时，才替换该键的条目。
boolean replace(K key, V oldValue, V newValue)
// 返回此映射中的键-值映射关系数。
int size()
// 返回此映射中包含的值的 Collection 视图。
Collection<V> values()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

五、ConcurrentHashMap源码分析

下面从ConcurrentHashMap的创建，获取，添加，删除这4个方面对ConcurrentHashMap进行分析。

a、构造函数

@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    // 参数有效性判断
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    // concurrencyLevel是“用来计算segments的容量”
    if (concurrencyLevel > MAX_SEGMENTS)
    //最大的并发等级(分段数组的长度)不能超过MAX_SEGMENTS 1<<16(也就是1的二进制向左移16位,65535)
        concurrencyLevel = MAX_SEGMENTS;
    int sshift = 0;
    int ssize = 1;
    // ssize=“大于或等于concurrencyLevel的最小的2的N次方值”
    //如果你传入的是15 就是向上取2的4次方倍 也就是16.
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    // 初始化segmentShift和segmentMask
    //segmentShift和segmentMask在定位segment使用，
    //segmentShift = 32 - ssize向左移位的次数，
    //segmentMask = ssize - 1。
    //ssize的最大长度是65536，对应的 segmentShift最大值为16，segmentMask最大值是65535，对应的二进制16位全为1；
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    // 哈希表的初始容量
    // 哈希表的实际容量=“segments的容量” x “segments中数组的长度”
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    // “哈希表的初始容量” / “segments的容量”
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    // cap就是“segments中的HashEntry数组的长度”
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
    // 1.初始化每个segment的HashEntry长度；
    // 2.创建segment数组和segment[0]。
    //HashEntry长度cap同样也是2的N次方，默认情况，ssize = 16，initialCapacity = 16，loadFactor = 0.75f
    //那么cap = 2，threshold = (int) cap * loadFactor = 1。阀值为1
    //HashEntry大小的计算也是2的N次方（cap <<=1）， cap的初始值为1，所以HashEntry最小的容量为2
    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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

整个初始化是通过参数initialCapacity(初始容量)，loadFactor(增长因子)和concurrencyLevel(并发等级)来初始化segmentShift（段偏移量）、segmentMask（段掩码）和segment数组。

说明：
(01) 前面我们说过，ConcurrentHashMap采用了“锁分段”技术；在代码中，它通过“segments数组”对象来保存各个分段。segments的定义如下：
final Segment

static final class Segment<K,V> extends ReentrantLock implements Serializable {
    ...

    transient volatile HashEntry<K,V>[] table;
    // threshold阈，是哈希表在其容量自动增加之前可以达到多满的一种尺度。
    transient int threshold;
    // loadFactor是加载因子
    final float loadFactor;

    Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
        this.loadFactor = lf;
        this.threshold = threshold;
        this.table = tab;
    }

    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

说明：Segment包含HashEntry数组，HashEntry保存了哈希表中的键值对。
此外，还需要说明的Segment继承于ReentrantLock。这意味着，Segment本质上就是可重入的互斥锁。

HashEntry的源码如下：

static final class HashEntry<K,V> {
    final int hash;    // 哈希值
    final K key;       // 键
    volatile V value;  // 值
    volatile HashEntry<K,V> next; // 下一个HashEntry节点

    HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

说明：和HashMap的节点一样，HashEntry也是链表。这就说明，ConcurrentHashMap是链式哈希表，它是通过“拉链法”来解决哈希冲突的。

注：segments.length一旦生产不会改变,rehash只是针对Segement中的hashtable而言！

b获取get()

下面以get(Object key)为例，对ConcurrentHashMap的获取方法进行说明。

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;
    // 获取key对应的Segment片段。
    // 如果Segment片段不为null，则在“Segment片段的HashEntry数组中”中找到key所对应的HashEntry列表；
    // 接着遍历该HashEntry链表，找到于key-value键值对对应的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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

说明：get(Object key)的作用是返回key在ConcurrentHashMap哈希表中对应的值。
它首先根据key计算出来的哈希值，获取key所对应的Segment片段。
如果Segment片段不为null，则在“Segment片段的HashEntry数组中”中找到key所对应的HashEntry列表。Segment包含“HashEntry数组”对象，而每一个HashEntry本质上是一个单向链表。
接着遍历该HashEntry链表，找到于key-value键值对对应的HashEntry节点。

读取的线程安全性

如何保证get()可见性？
HashTable中通过 synchronized get()方法保证了线程安全，但是低效。我们看看ConcurrentHashMap怎么做的：
保证读的安全性，就是要保证读取变量的原子性与可见性。

s = (Segment<K, V>) UNSAFE.getObjectVolatile(segments, u)) 
UNSAFE.getObjectVolatile(tab,((long) (((tab.length - 1) & h)) << TSHIFT) + TBASE)
1
2

保证了segement元素读取，以及(segement中)HashEntry[]数组中的元素读取的原子性、可见性。也就是通过这个方法保证了segement[]这个数组HashEntry[]数组 读的volatile语义。通常一个数组即使声明了volatile,但也无法保证volatile语义，这里使用UNSAFE方法在操作系统层面保证线程安全。当线程安全的读到了HashEntry元素，通过volatile声明保证其中value、next的volatile语义，从而保证线程安全：

     volatile V value;
     volatile HashEntry<K, V> next;
1
2

c增加put()

下面以put(K key, V value)来对ConcurrentHashMap中增加键值对来进行说明。

 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 //这里并不需要保证volatile语义，因为如果null则在ensureSegment保证；
                                                  //如果不为null,写操作会使用CAS保证
                                                    //nonvolatile; recheck
        (segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
            s = ensureSegment(j);// 获取到新初始化的segment
        return s.put(key, hash, value, false);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

说明：
(01) put()根据key获取对应的哈希值，再根据哈希值找到对应的Segment片段。如果Segment片段不存在，则新增一个Segment。
(02) 将key-value键值对添加到Segment片段中。

 /**
     * 根据segementIndex获取对应Segement,如果这个segem不存在,则创建一个
     * @param k
     *            the index
     * @return the segment
     */
    @SuppressWarnings("unchecked")
    private Segment<K, V> ensureSegment(int k) {
        final Segment<K, V>[] ss = this.segments;
        long u = (k << SSHIFT) + SBASE; // 计算segment对应index==u
        Segment<K, V> seg;
        if ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) {// 原子性检查是否未被初始化
            Segment<K, V> proto = ss[0]; // 使用ss[0]作为模板，并复制产生新的segment对象
            int cap = proto.table.length;// 获取模板HashEntry[].length
            float lf = proto.loadFactor;// 获取模板加载因子
            int threshold = (int) (cap * lf);// 获取模板阈值
            HashEntry<K, V>[] tab = (HashEntry<K, V>[]) new HashEntry[cap];// 初始化新的HashEntry[]数组
            if ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) { // recheck，防止已经被初始化；否则直接返回即可
                Segment<K, V> s = new Segment<K, V>(lf, threshold, tab);// 初始化新的segment
                // 自旋，直到初始化成功.通过CAS\getObjectVolatile保证原子性、可见性
                while ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) {
                    if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                        break;
                }
            }
        }
        return seg;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            // 没有获取到锁执行scanAndLockForPut
            HashEntry<K, V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);
            V oldValue;
            // 获取到锁,保证当前segment只能被一个线程使用
            try {
                HashEntry<K, V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K, V> first = entryAt(tab, index);// 获取HashEntry[]对应的HashEntry元素
                for (HashEntry<K, V> e = first;;) {
                    if (e != null) {// 表示HashEntry[]中存在key对应的HashEntry,按onlyIfAbsent规则进行覆盖
                        K k;
                        if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;// put结构化修改操作，modCount+1
                            }
                            break;
                        }
                        e = e.next;
                    } else {// 如果e==null，则这个key没有对应的HashEntry,则容器首次遇见这个key,初始化一个HashEntry
                        if (node != null)
                            node.setNext(first);
                        else
                            node = new HashEntry<K, V>(hash, key, value, first);
                        int c = count + 1;// segment中的HashEntry数组length+1.count表示HashEntry对象个数
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

说明：
put()的作用是将key-value键值对插入到“当前Segment对应的HashEntry中”，在插入前它会获取Segment对应的互斥锁，插入后会释放锁。具体的插入过程如下：
(01) 首先根据“hash值”获取“当前Segment的HashEntry数组对象”中的“HashEntry节点”，每个HashEntry节点都是一个单向链表。
(02) 接着，遍历HashEntry链表。
若在遍历HashEntry链表时，找到与“要key-value键值对”对应的节点，即“要插入的key-value键值对”的key已经存在于HashEntry链表中。则根据onlyIfAbsent进行判断，若onlyIfAbsent为true，即“当要插入的key不存在时才插入”，则不进行插入，直接返回；否则，用新的value值覆盖原始的value值，然后再返回。
若在遍历HashEntry链表时，没有找到与“要key-value键值对”对应的节点。当node!=null时，即在scanAndLockForPut()获取锁时，已经新建了key-value对应的HashEntry节点，则”将HashEntry添加到Segment中“；否则，新建key-value对应的HashEntry节点，然后再“将HashEntry添加到Segment中”。 在”将HashEntry添加到Segment中“前，会判断是否需要rehash。如果在添加key-value键值之后，容量会超过阈值，并且HashEntry数组的长度没有超过限制，则进行rehash；否则，直接通过setEntryAt()将key-value键值对添加到Segment中。
在介绍rehash()和setEntryAt()之前，我们先看看自旋函数scanAndLockForPut()。下面是它的源码：

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
    // 第一个HashEntry节点
    HashEntry<K,V> first = entryForHash(this, hash);
    // 当前的HashEntry节点
    HashEntry<K,V> e = first;
    HashEntry<K,V> node = null;
    // 重复计数(自旋计数器)
    int retries = -1; // negative while locating node

    // 查找”key-value键值对“在”HashEntry链表上对应的节点“；
    // 若找到的话，则不断的自旋；在自旋期间，若通过tryLock()获取锁成功则返回；否则自旋MAX_SCAN_RETRIES次数之后，强制获取”锁“并退出。
    // 若没有找到的话，则新建一个HashEntry链表。然后不断的自旋。
    // 此外，若在自旋期间，HashEntry链表的表头发生变化；则重新进行查找和自旋工作！
    while (!tryLock()) {
        HashEntry<K,V> f; // to recheck first below
        // 1. retries<0的处理情况
        if (retries < 0) {
            // 1.1 如果当前的HashEntry节点为空(意味着，在该HashEntry链表上上没有找到”要插入的键值对“对应的节点)，而且node=null；则新建HashEntry链表。
            if (e == null) {
                if (node == null) // speculatively create node
                    node = new HashEntry<K,V>(hash, key, value, null);
                retries = 0;
            }
            // 1.2 如果当前的HashEntry节点是”要插入的键值对在该HashEntry上对应的节点“，则设置retries=0
            else if (key.equals(e.key))
                retries = 0;
            // 1.3 设置为下一个HashEntry。
            else
                e = e.next;
        }
        // 2. 如果自旋次数超过限制，则获取“锁”并退出
        else if (++retries > MAX_SCAN_RETRIES) {
            lock();
            break;
        }
        // 3. 当“尝试了偶数次”时，就获取“当前Segment的第一个HashEntry”，即f。
        // 然后，通过f!=first来判断“当前Segment的第一个HashEntry是否发生了改变”。
        // 若是的话，则重置e，first和retries的值，并重新遍历。
        else if ((retries & 1) == 0 &&
                 (f = entryForHash(this, hash)) != first) {
            e = first = f; // re-traverse if entry changed
            retries = -1;
        }
    }
    return node;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

说明：
scanAndLockForPut()的目标是获取锁。流程如下：
它首先会调用entryForHash()，根据hash值获取”当前Segment中对应的HashEntry节点(first)，即找到对应的HashEntry链表“。
紧接着进入while循环。在while循环中，它会遍历”HashEntry链表(e)“，查找”要插入的key-value键值对“在”该HashEntry链表上对应的节点“。
若找到的话，则不断的自旋，即不断的执行while循环。在自旋期间，若通过tryLock()获取锁成功则返回；否则，在自旋MAX_SCAN_RETRIES次数之后，强制获取锁并退出。
若没有找到的话，则新建一个HashEntry链表，然后不断的自旋。在自旋期间，若通过tryLock()获取锁成功则返回；否则，在自旋MAX_SCAN_RETRIES次数之后，强制获取锁并退出。
此外，若在自旋期间，HashEntry链表的表头发生变化；则重新进行查找和自旋工作！
理解scanAndLockForPut()时，务必要联系”哈希表“的数据结构。一个Segment本身就是一个哈希表，Segment中包含了”HashEntry数组“对象，而每一个HashEntry对象本身是一个”单向链表“。

扩容rehash

下面看看rehash()的实现代码。

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    // ”Segment中原始的HashEntry数组的长度“
    int oldCapacity = oldTable.length;
    // ”Segment中新HashEntry数组的长度“
    int newCapacity = oldCapacity << 1;
    // 新的阈值
    threshold = (int)(newCapacity * loadFactor);
    // 新的HashEntry数组
    HashEntry<K,V>[] newTable =
        (HashEntry<K,V>[]) new HashEntry[newCapacity];
    int sizeMask = newCapacity - 1;
    // 遍历”原始的HashEntry数组“，
    // 将”原始的HashEntry数组“中的每个”HashEntry链表“的值，都复制到”新的HashEntry数组的HashEntry元素“中。
    for (int i = 0; i < oldCapacity ; i++) {
        // 获取”原始的HashEntry数组“中的”第i个HashEntry链表“
        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;
                // 将”原始的HashEntry数组“中的”HashEntry链表(e)“的值，都复制到”新的HashEntry数组的HashEntry“中。
                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节点添加到“Segment的新HashEntry数组(newTable)“中。
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    table = newTable;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

说明：rehash()的作用是将”Segment的容量“变为”原始的Segment容量的2倍“。
在将原始的数据拷贝到“新的Segment”中后，会将新增加的key-value键值对添加到“新的Segment”中。

注：可以看到rehash是针对某个segment做的扩容，而非对所有Segement。并且是先判断在扩容，然后插入新的元素。这点相对HashMap的扩容更合理，HashMap插入后再去判断扩容，有可能扩容后并不会有新元素进来，也就是失去了扩容的意义。

setEntryAt()的源码如下：
static final

static final sun.misc.Unsafe UNSAFE;
1

Unsafe.java在openjdk6中的路径是：openjdk6/jdk/src/share/classes/sun/misc/Unsafe.java。其中，putOrderedObject()的源码下：

public native void putOrderedObject(Object o, long offset, Object x);
1

说明：putOrderedObject()是一个本地方法。
它会设置obj对象中offset偏移地址对应的object型field的值为指定值。它是一个有序或者有延迟的putObjectVolatile()方法，并且不保证值的改变被其他线程立即看到。只有在field被volatile修饰并且期望被意外修改的时候，使用putOrderedObject()才有用。
总之，setEntryAt()的目的是设置tab中第i位置元素的值为e，且该设置会有延迟。

d删除delete()

下面以remove(Object key)来对ConcurrentHashMap中的删除操作来进行说明。

public V remove(Object key) {
    int hash = hash(key);
    // 根据hash值，找到key对应的Segment片段。
    Segment<K,V> s = segmentForHash(hash);
    return s == null ? null : s.remove(key, hash, null);
}
1
2
3
4
5
6

说明：remove()首先根据“key的计算出来的哈希值”找到对应的Segment片段，然后再从该Segment片段中删除对应的“key-value键值对”。
remove()的方法如下：

final V remove(Object key, int hash, Object value) {
    // 尝试获取Segment对应的锁。
    // 尝试失败的话，则通过scanAndLock()来获取锁。
    if (!tryLock())
        scanAndLock(key, hash);
    V oldValue = null;
    try {
        // 根据“hash值”找到“Segment的HashEntry数组”中对应的“HashEntry节点(e)”，该HashEntry节点是一HashEntry个链表。
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash;
        HashEntry<K,V> e = entryAt(tab, index);
        HashEntry<K,V> pred = null;
        // 遍历“HashEntry链表”，删除key-value键值对
        while (e != null) {
            K k;
            HashEntry<K,V> next = e.next;
            if ((k = e.key) == key ||
                (e.hash == hash && key.equals(k))) {
                V v = e.value;
                if (value == null || value == v || value.equals(v)) {
                    if (pred == null)
                        setEntryAt(tab, index, next);
                    else
                        pred.setNext(next);
                    ++modCount;
                    --count;
                    oldValue = v;
                }
                break;
            }
            pred = e;
            e = next;
        }
    } finally {
        // 释放锁
        unlock();
    }
    return oldValue;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

说明：remove()的目的就是删除key-value键值对。在删除之前，它会获取到Segment的互斥锁，在删除之后，再释放锁。
它的删除过程也比较简单，它会先根据hash值，找到“Segment的HashEntry数组”中对应的“HashEntry”节点。根据Segment的数据结构，我们知道Segment中包含一个HashEntry数组对象，而每一个HashEntry本质上是一个单向链表。 在找到“HashEntry”节点之后，就遍历该“HashEntry”节点对应的链表，找到key-value键值对对应的节点，然后删除。

下面对scanAndLock()进行说明。它的源码如下：

private void scanAndLock(Object key, int hash) {
    // 第一个HashEntry节点
    HashEntry<K,V> first = entryForHash(this, hash);
    HashEntry<K,V> e = first;
    int retries = -1;

    // 查找”key-value键值对“在”HashEntry链表上对应的节点“；
    // 无论找没找到，最后都会不断的自旋；在自旋期间，若通过tryLock()获取锁成功则返回；否则自旋MAX_SCAN_RETRIES次数之后，强制获取”锁“并退出。
    // 若在自旋期间，HashEntry链表的表头发生变化；则重新进行查找和自旋！
    while (!tryLock()) {
        HashEntry<K,V> f;
        if (retries < 0) {
            // 如果“遍历完该HashEntry链表，仍然没找到”要删除的键值对“对应的节点”
            // 或者“在该HashEntry链表上找到”要删除的键值对“对应的节点”，则设置retries=0
            // 否则，设置e为下一个HashEntry节点。
            if (e == null || key.equals(e.key))
                retries = 0;
            else
                e = e.next;
        }
        // 自旋超过限制次数之后，获取锁并退出。
        else if (++retries > MAX_SCAN_RETRIES) {
            lock();
            break;
        }
        // 当“尝试了偶数次”时，就获取“当前Segment的第一个HashEntry”，即f。
        // 然后，通过f!=first来判断“当前Segment的第一个HashEntry是否发生了改变”。
        // 若是的话，则重置e，first和retries的值，并重新遍历。
        else if ((retries & 1) == 0 &&
                 (f = entryForHash(this, hash)) != first) {
            e = first = f;
            retries = -1;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

说明：scanAndLock()的目标是获取锁。它的实现与scanAndLockForPut()类似，这里就不再过多说明。

e获取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 (;;) {
            //RETRIES_BEFORE_LOCK为不变常量2 尝试两次不锁住Segment的方式来统计每个Segment的大小,如果在统计的过程中Segment的count发生变化,这时候再加锁统计Segment的count
                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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

说明：
size方法的实现是遍历所有的segment，统计累计所有segment里元素的个数。

这个遍历会做两次，如果两次计算中结构性变化的次数（modCount）相等，那么就直接完成返回。如果第一次遍历统计与第二次遍历统计直接发生了结构化操作（比如、put被另一个线程执行了），那么再尝试一次，如果第二次与第三次统计的结果依旧不相等，则动用Lock锁，锁住所有的segment（其他线程的put、clear等操作被阻塞）。接下来，再次统计两次，这次由于锁保持了互斥，所以不会被其他线程干扰，modCount不会改变，sum == last，返回统计值，并且要释放所有Segement锁。

前三次计算size，是无锁的操作。以提高性能。其实这里有个优化点，第一次的size并不用真的计算出来。可以只计算后两次可能会真实使用的size即可。当然这样的锁是非常低效的，通常并发的场景中不会发生。

关于size 再引用一个我觉得很好的例子:一个Map有4个Segment，标记为S1，S2，S3，S4，现在我们要获取Map的size。计算过程 是这样的：

• 第一次计算，不对S1，S2，S3，S4加锁，遍历所有的Segment，假设每个Seg
  ment的大小分别为1，2，3，4，更新操作(添加或删除)次数分别为：2，2，3，1，则这次计算可以得
  到Map的总大小为1+2+3+4=10，总共更新操作次数为2+2+3+1=8；
• 第二次计算，不对S1,S 2,S3,S4加锁，遍历所有Segment，假设这次每个Segment的大小变成了2，2，3，4，更
  新次数分别为3，2，3，1，因为两次计算得到的Map更新次数不一致(第一次是8，第二
  次是9)则可以断定这段时间Map数据被更新，则此时应该再试一次；
• 第三次计算，不对S 1，S2，S3，S4加锁，遍历所有Segment，假设每个Segment的更新操作次数还是为3，2
  ，3，1，则因为第二次计算和第三次计算得到的Map的更新操作的次数是一致的，就能
  说明第二次计算和第三次计算这段时间内Map数据没有被更新，此时可以直接返回第三
  次计算得到的Map的大小。最坏的情况：第三次计算得到的数据更新次数和第二次也不 一样，则只能先对所有Segment加锁再计算最后解锁。

六总结

ConcurrentHashMap是线程安全的哈希表，它是通过“锁分段”来实现的。ConcurrentHashMap中包括了“Segment(锁分段)数组”，每个Segment就是一个哈希表，而且也是可重入的互斥锁。

• 第一，Segment是哈希表表现在，Segment包含了“HashEntry数组”，而“HashEntry数组”中的每一个HashEntry元素是一个单向链表。即Segment是通过链式哈希表。
• 第二，Segment是可重入的互斥锁表现在，Segment继承于ReentrantLock，而ReentrantLock就是可重入的互斥锁。
  对于ConcurrentHashMap的添加，删除操作，在操作开始前，线程都会获取Segment的互斥锁；操作完毕之后，才会释放。
• 第三、对于读取操作，它是通过volatile去实现的，HashEntry数组是volatile类型的，而volatile能保证“即对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入”，即我们总能读到其它线程写入HashEntry之后的值

• 第四、对于扩容来说，ConcurrentHashMap将Segment的容量“变为”原始的Segment容量的2倍“。
  在将原始的数据拷贝到“新的Segment”中后，会将新增加的key-value键值对添加到“新的Segment”中。rehash是针对某个segment做的扩容，而非对所有Segement。并且是先判断在扩容，然后插入新的元素。这点相对HashMap的扩容更合理，HashMap插入后再去判断扩容，有可能扩容后并不会有新元素进来，也就是失去了扩容的意义。

• 第五、对于获取ConcurrentHashMap的长度是循环所有的segment，统计所有segment里元素的个数。

  这个遍历会做两次，如果两次计算中结构性变化的次数（modCount）相等，那么就直接完成返回。如果第一次遍历统计与第二次遍历统计直接发生了结构化操作（比如、put被另一个线程执行了），那么再尝试一次，如果第二次与第三次统计的结果依旧不相等，则动用Lock锁，锁住所有的segment（其他线程的put、clear等操作被阻塞）。接下来，再次统计两次，这次由于锁保持了互斥，所以不会被其他线程干扰，modCount不会改变，sum
  == last，返回统计值，并且要释放所有Segement锁。