ConcurrentHashMap 的工作原理及代码实现

　　ConcurrentHashMap采用了非常精妙的"分段锁"策略，ConcurrentHashMap的主干是个Segment数组。Segment继承了ReentrantLock，所以它就是一种可重入锁（ReentrantLock)。在ConcurrentHashMap，一个Segment就是一个子哈希表，Segment里维护了一个HashEntry数组，并发环境下，对于不同Segment的数据进行操作是不用考虑锁竞争的。

　　当问到我们有关于ConcurrentHashMap的工作原理以及实现时，可以从以下几个方面说：

• ConcurrentHashMap的优点，即HashMap和HashTable的缺点。

• ConcurrentHashMap两个静态内部类：HsahEntry和segment
• ConcurrentHashMap含有16个segment
• ConcurrentHashMap的put方法：根据hash值找到对应的segment，segment是分段锁。
• ConcurrentHashMap的get方法：count>0,hash找到HashEntry,hash相等并且key相同，若取value为null，加锁重新获取。
• ConcurrentHashMap的remove方法：加锁，每删除一个元素就将那之前的元素克隆一边。因为设置为第一次next之后不能再改变。
• ConcurrentHashMap的size（）方法：2次不锁住segment方式统计各个segment的大小，若count发生变化，采用加锁方式统计。modCount变量，在put，remove和clean方法里操作元素，modcount加1.

ConcurrentHashMap是Java1.5中引用的一个线程安全的支持高并发的HashMap集合类。

1、线程不安全的HashMap

因为多线程环境下，使用Hashmap进行put操作会引起死循环，导致CPU利用率接近100%，所以在并发情况下不能使用HashMap。

2、效率低下的HashTable

HashTable容器使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。

因为当一个线程访问HashTable的同步方法时，其他线程访问HashTable的同步方法时，可能会进入阻塞或轮询状态。

如线程1使用put进行添加元素，线程2不但不能使用put方法添加元素，并且也不能使用get方法来获取元素，所以竞争越激烈效率越低。

3、锁分段技术

HashTable容器在竞争激烈的并发环境下表现出效率低下的原因，是因为所有访问HashTable的线程都必须竞争同一把锁，

那假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，

从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。

首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。

这里“按顺序”是很重要的，否则极有可能出现死锁，在ConcurrentHashMap内部，段数组是final的，并且其成员变量实际上也是final的，

但是，仅仅是将数组声明为final的并不保证数组成员也是final的，这需要实现上的保证。这可以确保不会出现死锁，因为获得锁的顺序是固定的。

oncurrentHashMap 类中包含两个静态内部类 HashEntry 和 Segment。

HashEntry 用来封装映射表的键 / 值对;Segment 用来充当锁的角色，每个 Segment 对象守护整个散列映射表的若干个桶。

每个桶是由若干个 HashEntry 对象链接起来的链表。一个 ConcurrentHashMap 实例中包含由若干个 Segment 对象组成的数组。

每个Segment守护者一个HashEntry数组里的元素,当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。

5、HashEntry类

static final class HashEntry<K,V> {
            final K key;                 // 声明 key 为 final 型
            final int hash;              // 声明 hash 值为 final 型
            volatile V value;           // 声明 value 为 volatile 型
            final HashEntry<K,V> next;  // 声明 next 为 final 型 

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

每个HashEntry代表Hash表中的一个节点，在其定义的结构中可以看到，除了value值没有定义final，其余的都定义为final类型，我们知道Java中关键词final修饰的域成为最终域。

用关键词final修饰的变量一旦赋值，就不能改变，也称为修饰的标识为常量。这就意味着我们删除或者增加一个节点的时候，就必须从头开始重新建立Hash链，因为next引用值需要改变。

由于 HashEntry 的 next 域为 final 型，所以新节点只能在链表的表头处插入。 例如将A,B,C插入空桶中，插入后的结构为：

6、segment类

static final class Segment<K,V> extends ReentrantLock implements Serializable {
     private static final long serialVersionUID = 2249069246763182397L;
             /**
              * 在本 segment 范围内，包含的 HashEntry 元素的个数
              * 该变量被声明为 volatile 型,保证每次读取到最新的数据
              */
             transient volatile int count;  

             /**
              *table 被更新的次数
              */
             transient int modCount;  

             /**
              * 当 table 中包含的 HashEntry 元素的个数超过本变量值时，触发 table 的再散列
              */
             transient int threshold;  

             /**
              * table 是由 HashEntry 对象组成的数组
              * 如果散列时发生碰撞，碰撞的 HashEntry 对象就以链表的形式链接成一个链表
              * table 数组的数组成员代表散列映射表的一个桶
              * 每个 table 守护整个 ConcurrentHashMap 包含桶总数的一部分
              * 如果并发级别为 16，table 则守护 ConcurrentHashMap 包含的桶总数的 1/16
              */
             transient volatile HashEntry<K,V>[] table;  

             /**
              * 装载因子
              */
             final float loadFactor;
     }

Segment 类继承于 ReentrantLock 类，从而使得 Segment 对象能充当锁的角色。每个 Segment 对象用来守护其（成员对象 table 中）包含的若干个桶。

table 是一个由 HashEntry 对象组成的数组。table 数组的每一个数组成员就是散列映射表的一个桶。

每一个 Segment 对象都有一个 count 对象来表示本 Segment 中包含的 HashEntry 对象的总数。

之所以在每个 Segment 对象中包含一个计数器，而不是在 ConcurrentHashMap 中使用全局的计数器，是为了避免出现“热点域”而影响 ConcurrentHashMap 的并发性。

下图是依次插入 ABC 三个 HashEntry 节点后，Segment 的结构示意图。

7、ConcurrentHashMap 类

默认的情况下，每个ConcurrentHashMap 类会创建16个并发的segment，每个segment里面包含多个Hash表，每个Hash链都是有HashEntry节点组成的。

如果键能均匀散列，每个 Segment 大约守护整个散列表中桶总数的 1/16。

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
           implements ConcurrentMap<K, V>, Serializable { 

           /**
        * 散列映射表的默认初始容量为 16，即初始默认为 16 个桶
        * 在构造函数中没有指定这个参数时，使用本参数
        */
       static final     int DEFAULT_INITIAL_CAPACITY= 16; 

       /**
        * 散列映射表的默认装载因子为 0.75，该值是 table 中包含的 HashEntry 元素的个数与
    * table 数组长度的比值
        * 当 table 中包含的 HashEntry 元素的个数超过了 table 数组的长度与装载因子的乘积时，
    * 将触发 再散列
        * 在构造函数中没有指定这个参数时，使用本参数
        */
       static final float DEFAULT_LOAD_FACTOR= 0.75f; 

       /**
        * 散列表的默认并发级别为 16。该值表示当前更新线程的估计数
        * 在构造函数中没有指定这个参数时，使用本参数
        */
       static final int DEFAULT_CONCURRENCY_LEVEL= 16; 

       /**
        * segments 的掩码值
        * key 的散列码的高位用来选择具体的 segment
        */
       final int segmentMask; 

       /**
        * 偏移量
        */
       final int segmentShift; 

       /**
        * 由 Segment 对象组成的数组
        */
       final Segment<K,V>[] segments; 

       /**
        * 创建一个带有指定初始容量、加载因子和并发级别的新的空映射。
        */
       public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
           if(!(loadFactor > 0) || initialCapacity < 0 ||
    concurrencyLevel <= 0)
               throw new IllegalArgumentException(); 

           if(concurrencyLevel > MAX_SEGMENTS)
               concurrencyLevel = MAX_SEGMENTS; 

           // 寻找最佳匹配参数（不小于给定参数的最接近的 2 次幂）
           int sshift = 0;
           int ssize = 1;
           while(ssize < concurrencyLevel) {
               ++sshift;
               ssize <<= 1;
           }
           segmentShift = 32 - sshift;       // 偏移量值
           segmentMask = ssize - 1;           // 掩码值
           this.segments = Segment.newArray(ssize);   // 创建数组

           if (initialCapacity > MAXIMUM_CAPACITY)
               initialCapacity = MAXIMUM_CAPACITY;
           int c = initialCapacity / ssize;
           if(c * ssize < initialCapacity)
               ++c;
           int cap = 1;
           while(cap < c)
               cap <<= 1; 

           // 依次遍历每个数组元素
           for(int i = 0; i < this.segments.length; ++i)
               // 初始化每个数组元素引用的 Segment 对象
    this.segments[i] = new Segment<K,V>(cap, loadFactor);
       } 

       /**
        * 创建一个带有默认初始容量 (16)、默认加载因子 (0.75) 和 默认并发级别 (16)
     * 的空散列映射表。
        */
       public ConcurrentHashMap() {
           // 使用三个默认参数，调用上面重载的构造函数来创建空散列映射表
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
    }

8、 用分离锁实现多个线程间的并发写操作

插入数据后的ConcurrentHashMap的存储形式

（1）Put方法的实现

首先，根据 key 计算出对应的 hash 值：

public V put(K key, V value) {
       if (value == null)          //ConcurrentHashMap 中不允许用 null 作为映射值
           throw new NullPointerException();
       int hash = hash(key.hashCode());        // 计算键对应的散列码
       // 根据散列码找到对应的 Segment
       return segmentFor(hash).put(key, hash, value, false);
    }
     根据 hash 值找到对应的 Segment：
    /**
    * 使用 key 的散列码来得到 segments 数组中对应的 Segment
    */
    final Segment<K,V> segmentFor(int hash) {
    // 将散列值右移 segmentShift 个位，并在高位填充 0
    // 然后把得到的值与 segmentMask 相“与”
    // 从而得到 hash 值对应的 segments 数组的下标值
    // 最后根据下标值返回散列码对应的 Segment 对象
        return segments[(hash >>> segmentShift) & segmentMask];
    }

在这个 Segment 中执行具体的 put 操作：

V put(K key, int hash, V value, boolean onlyIfAbsent) {
           lock();  // 加锁，这里是锁定某个 Segment 对象而非整个 ConcurrentHashMap
           try {
               int c = count; 

               if (c++ > threshold)     // 如果超过再散列的阈值
                   rehash();              // 执行再散列，table 数组的长度将扩充一倍

               HashEntry<K,V>[] tab = table;
               // 把散列码值与 table 数组的长度减 1 的值相“与”
               // 得到该散列码对应的 table 数组的下标值
               int index = hash & (tab.length - 1);
               // 找到散列码对应的具体的那个桶
               HashEntry<K,V> first = tab[index]; 

               HashEntry<K,V> e = first;
               while (e != null && (e.hash != hash || !key.equals(e.key)))
                   e = e.next; 

               V oldValue;
               if (e != null) {            // 如果键 / 值对以经存在
                   oldValue = e.value;
                   if (!onlyIfAbsent)
                       e.value = value;    // 设置 value 值
               }
               else {                        // 键 / 值对不存在
                   oldValue = null;
                   ++modCount;         // 要添加新节点到链表中，所以 modCont 要加 1
                   // 创建新节点，并添加到链表的头部
                   tab[index] = new HashEntry<K,V>(key, hash, first, value);
                   count = c;               // 写 count 变量
               }
               return oldValue;
           } finally {
               unlock();                     // 解锁
           }
       `}

这里的加锁操作是针对（键的 hash 值对应的）某个具体的 Segment，锁定的是该 Segment 而不是整个 ConcurrentHashMap。

因为插入键 / 值对操作只是在这个 Segment 包含的某个桶中完成，不需要锁定整个ConcurrentHashMap。

此时，其他写线程对另外 15 个Segment 的加锁并不会因为当前线程对这个 Segment 的加锁而阻塞。

同时，所有读线程几乎不会因本线程的加锁而阻塞（除非读线程刚好读到这个 Segment 中某个 HashEntry 的 value 域的值为 null，此时需要加锁后重新读取该值）。

（2）Get方法的实现

V get(Object key, int hash) {
        if(count != 0) {       // 首先读 count 变量
            HashEntry<K,V> e = getFirst(hash);
            while(e != null) {
                if(e.hash == hash && key.equals(e.key)) {
                    V v = e.value;
                    if(v != null)
                        return v;
                    // 如果读到 value 域为 null，说明发生了重排序，加锁后重新读取
                    return readValueUnderLock(e);
                }
                e = e.next;
            }
        }
        return null;
    }
     V readValueUnderLock(HashEntry<K,V> e) {
         lock();
         try {
             return e.value;
         } finally {
             unlock();
         }
     }

ConcurrentHashMap中的读方法不需要加锁，所有的修改操作在进行结构修改时都会在最后一步写count 变量，通过这种机制保证get操作能够得到几乎最新的结构更新。

（3）Remove方法的实现

V remove(Object key, int hash, Object value) {
        lock(); //加锁
        try{
            int c = count - 1;
            HashEntry<K,V>[] tab = table;
            //根据散列码找到 table 的下标值
            int index = hash & (tab.length - 1);
            //找到散列码对应的那个桶
            HashEntry<K,V> first = tab[index];
            HashEntry<K,V> e = first;
            while(e != null&& (e.hash != hash || !key.equals(e.key)))
                e = e.next; 

            V oldValue = null;
            if(e != null) {
                V v = e.value;
                if(value == null|| value.equals(v)) { //找到要删除的节点
                    oldValue = v;
                    ++modCount;
                    //所有处于待删除节点之后的节点原样保留在链表中
                    //所有处于待删除节点之前的节点被克隆到新链表中
                    HashEntry<K,V> newFirst = e.next;// 待删节点的后继结点
                    for(HashEntry<K,V> p = first; p != e; p = p.next)
                        newFirst = new HashEntry<K,V>(p.key, p.hash,
                                                      newFirst, p.value);
                    //把桶链接到新的头结点
                    //新的头结点是原链表中，删除节点之前的那个节点
                    tab[index] = newFirst;
                    count = c;      //写 count 变量
                }
            }
            return oldValue;
        } finally{
            unlock(); //解锁
        }
    }

整个操作是在持有段锁的情况下执行的，空白行之前的行主要是定位到要删除的节点e。

如果不存在这个节点就直接返回null，否则就要将e前面的结点复制一遍，尾结点指向e的下一个结点。

e后面的结点不需要复制，它们可以重用。

中间那个for循环是做什么用的呢？从代码来看，就是将定位之后的所有entry克隆并拼回前面去，但有必要吗？

每次删除一个元素就要将那之前的元素克隆一遍？这点其实是由entry的不变性来决定的，仔细观察entry定义，发现除了value，其他所有属性都是用final来修饰的，

这意味着在第一次设置了next域之后便不能再改变它，取而代之的是将它之前的节点全都克隆一次。至于entry为什么要设置为不变性，这跟不变性的访问不需要同步从而节省时间有关。

（4）containsKey方法的实现，它不需要读取值。

boolean containsKey(Object key, int hash) {
         if (count != 0) { // read-volatile
             HashEntry<K,V> e = getFirst(hash);
             while (e != null) {
                 if (e.hash == hash && key.equals(e.key))
                     return true;
                 e = e.next;
             }
         }
         return false;
     } 

（5）size()

我们要统计整个ConcurrentHashMap里元素的大小，就必须统计所有Segment里元素的大小后求和。

Segment里的全局变量count是一个volatile变量，那么在多线程场景下，我们是不是直接把所有Segment的count相加就可以得到整个ConcurrentHashMap大小了呢？

不是的，虽然相加时可以获取每个Segment的count的最新值，但是拿到之后可能累加前使用的count发生了变化，那么统计结果就不准了。

所以最安全的做法，是在统计size的时候把所有Segment的put，remove和clean方法全部锁住，但是这种做法显然非常低效。

因为在累加count操作过程中，之前累加过的count发生变化的几率非常小，所以ConcurrentHashMap的做法是先尝试2次通过不锁住Segment的方式来统计各个Segment大小，如果统计的过程中，容器的count发生了变化，则再采用加锁的方式来统计所有Segment的大小。

那么ConcurrentHashMap是如何判断在统计的时候容器是否发生了变化呢？使用modCount变量，在put , remove和clean方法里操作元素前都会将变量modCount进行加1，那么在统计size前后比较modCount是否发生变化，从而得知容器的大小是否发生变化。

9、总结

1.在使用锁来协调多线程间并发访问的模式下，减小对锁的竞争可以有效提高并发性。

有两种方式可以减小对锁的竞争：

减小请求同一个锁的频率。

减少持有锁的时间。

2.ConcurrentHashMap 的高并发性主要来自于三个方面：

用分离锁实现多个线程间的更深层次的共享访问。

用 HashEntery 对象的不变性来降低执行读操作的线程在遍历链表期间对加锁的需求。

通过对同一个 Volatile 变量的写 / 读访问，协调不同线程间读 / 写操作的内存可见性。

使用分离锁，减小了请求同一个锁的频率。