ConcurrentHashMap优点与源码剖析

哈希表是中非常高效，复杂度为O(1)的数据结构，在Java开发中，我们最常见到最频繁使用的就是HashMap和HashTable，但是在线程竞争激烈的并发场景中使用都不够合理。 

　HashMap ：HashMap是线程不安全的，在多线程环境下，HashMap的put操作会引起死循环，导致CPU的利用率接近100%。因为多线程会导致HashMap的Entry链表形成环形链表，导致Entry的next节点永远不为空，就会产生死循环获取Entry，因此在并发环境中使用HashMap是非常危险的。

　HashTable ： HashTable和HashMap的实现原理几乎一样，差别无非是

1.HashTable不允许key和value为null；

2.HashTable是线程安全的。但是HashTable线程安全的策略实现代价却太大了，简单粗暴，get/put所有相关操作都是synchronized的，这相当于给整个哈希表加了一把大锁，多线程访问时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞，相当于将所有的操作串行化，在竞争激烈的并发场景中性能就会非常差。

 ConcurrentMap

ConcurrentMap也是价值对形式来存储数据，实现了Map接口，并提供了几个原子操作方法

public interface ConcurrentMap<K, V> extends Map<K, V> {}

//如果指定键已经不在和某个值关联，则他和给定值关联
V putIfAbsent(K key, V value);
//只有目前将键映射到给定的value时，才移除该键值对   返回值Boolean类型， true:成功 false：失败
boolean remove(Object key, Object value);
//只有当key和oldValue同时存在时，才会将oldValue替换为newValue
boolean replace(K key, V oldValue, V newValue);
//只有在集合中存在该key,才完成替换
V replace(K key, V value); 

但是HashMap仍是非线程安全的，在多线程并发的情况下add/get可能引入死循环，导致cpu利用率趋近于100%，解决方案有HashTable或者Collections.synchronizedMap(map)，这两个解决方案底层对读写方法进行加锁。此外还有一种结构：ConcurrentHashMap也是线程安全的。

 ConcurrentHashMap

底层实现 

//用来存储数据 是一个Segment数组
final Segment<K,V>[] segments;

//segment是继承自ReentrantLock，实现了锁机制
static final class Segment<K,V> extends ReentrantLock implements Serializable {
       //重入次数   加锁操作发送冲突需要考虑重入问题
        static final int MAX_SCAN_RETRIES =
            Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
        //数据存放在table中，是volatile修饰
        transient volatile HashEntry<K,V>[] table;
        Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
            this.loadFactor = lf;
            this.threshold = threshold;
            this.table = tab;
        }
}

 static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry<K,V> next;

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

ConcurrentHashMap是segment数组+哈希表结构

通过源码可知：Segment是ReentrantLock来修饰的，Segment继承了ReentrantLock，所以它就是一种可重入锁（ReentrantLock)，其本质是一把锁，称之为分段锁。在ConcurrentHashMap，一个Segment就是一个子哈希表，Segment里维护了一个HashEntry数组，并发环境下，对于不同的Segment的数据进行操作是不用考虑锁竞争的。

HashTable性能差主要是由于所有操作需要竞争同一把锁，而如果容器中有多把锁，每一把锁锁一段数据，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这样便可以有效地提高并发效率。这就是ConcurrentHashMap所采用的"分段锁"思想。

 转自(ConcurrentHashMap实现原理及源码分析 - dreamcatcher-cx - 博客园 (cnblogs.com))

构造函数中concurrencyLevel称之为并发度，该参数是用来实例化segment数组的带下，默认的大小是16个，即同一时刻并发量线程量至少是16个。

在ConcurrentHashMap中变更操作(put，remove，replace)加锁处理，针对get读操作是可以共享操作，读操作可以同时有多个线程操作。

并发度concurrencyLevel默认是16，也可以自行指定，指定的并发度需要满足2的倍数关系，目的方法快速的进行key哈希找到对应存储位置，并发度一旦确定之后是不在改变的，在Concurrent使用过程中数量超过扩容阈值时，也只是对segment下的哈希表进行扩容。

ConcurrentHashMap的高并发主要来源于：

1、采用分段锁实现多个线程间的共享访问

2、用HashEntry对象的不变性来降低执行读操作的线程在遍历链表期间对加锁的要求

3、对于同一个volatile变量的读/写操作，协调不同线程间的读写内存的可见性问题

在1.8之后底层实现换成了CAS，把锁分段机制放弃了，CAS基本上是可以达到无锁境界

CAS + volatile 无锁编程

put流程

   public V put(K key, V value) {
       //key，value不能为null
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
       //通过key进行哈希到对应segment位置
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        //通过位置j获取当前的对应segment起始位置
        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);
    }

  #内部类Segment下的put方法
        final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            //尝试性加锁
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                //当前segment下的table
                HashEntry<K,V>[] tab = table;
                //通过key的哈希值进行哈希找到对应table位置
                int index = (tab.length - 1) & hash;
                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) {
                            //put方法处理：将新value替换oldvalue
                                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;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                        //超过扩容阈值
                            rehash(node);
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
            //释放锁
                unlock();
            }
            return oldValue;
        }
        
     //扩容仅针对某个segment进行扩容，而不是对整个ConcurrentHashMap进行扩容
      private void rehash(HashEntry<K,V> node) {
          //在segment下的table
            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;
            //将原有table上的所有hashentry节点进行重新哈希到新table上
            for (int i = 0; i < oldCapacity ; i++) {
                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;
                        // Clone remaining nodes
                        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);
                        }
                    }
                }
            }
            int nodeIndex = node.hash & sizeMask; // add the new node
            node.setNext(newTable[nodeIndex]);
            newTable[nodeIndex] = node;
            table = newTable;
        }

使用对比

分别使用HashTable,Collection.synchornizedMap(map),ConcurrentHashMap这三个集合，循环100次创建50个线程往这三个集合中同时添加5000个元素，获取其中的元素， 分析使用不同集合put get的效率

package thread;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;

class PutThread extends Thread{
    private Map<String, Integer> map;
    private CountDownLatch countDownLatch;
    private String key = this.getId()+"";

    public PutThread(Map<String, Integer> map, CountDownLatch countDownLatch){
        this.map = map;
        this.countDownLatch = countDownLatch;
    }

    public void run(){
        for(int i=0; i<5000; i++){
            map.put(key, i);
        }
        countDownLatch.countDown(); //-1
    }
}

class GetThread extends Thread{
    private Map<String, Integer> map;
    private CountDownLatch countDownLatch;
    private String key = this.getId()+"";

    public GetThread(Map<String, Integer> map, CountDownLatch countDownLatch){
        this.map = map;
        this.countDownLatch = countDownLatch;
    }

    public void run(){
        for(int i=0; i<5000; i++){
            map.get(key);
        }
        countDownLatch.countDown();
    }
}

class TestDemo14 {
    private static final int THREADNUM = 50;
    public static long put(Map<String, Integer> map){
        long start = System.currentTimeMillis();
        //起50个线程添加5000个元素
        CountDownLatch countDownLatch = new CountDownLatch(THREADNUM);
        for(int i=0; i < THREADNUM; i++){
            new PutThread(map, countDownLatch).start();
        }
        try {
            countDownLatch.await(); //计数器为0 打破阻塞
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return System.currentTimeMillis()-start;
    }

    public static long get(Map<String, Integer> map){
        //起50个线程获取5000个元素
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(THREADNUM);

        for(int i=0; i<THREADNUM; i++){
            new GetThread(map, countDownLatch).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return System.currentTimeMillis()-start;
    }

    public static void main(String[] args) {
        Map<String, Integer> hashmapSync = Collections.synchronizedMap(new HashMap<String, Integer>());

        Map<String, Integer> hashtable = new Hashtable<>();

        Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();

        long totalA = 0L; //Collections.synchronizedMap
        long totalB = 0L; //HashTable
        long totalC = 0L; //ConcurrentHashMap
        //计算put方法的总耗时
        for(int i = 0; i < 100; i++){
            totalA += put(hashmapSync);
            totalB += put(hashtable);
            totalC += put(concurrentMap);
        }

        System.out.println("put time Collections.synchronizedMap = " +totalA+".ms");
        System.out.println("put time Hashtable = " +totalB+".ms");
        System.out.println("put time ConcurrentHashMap = " +totalC+".ms");

        totalA = 0L; //Collections.synchronizedMap
        totalB = 0L; //HashTable
        totalC = 0L; //ConcurrentHashMap

        //计算get方法的总耗时
        for(int i=0; i<100; i++){
            totalA += get(hashmapSync);
            totalB += get(hashtable);
            totalC += get(concurrentMap);
        }

        System.out.println("get time Collections.synchronizedMap = " +totalA+".ms");
        System.out.println("get time Hashtable = " +totalB+".ms");
        System.out.println("get time ConcurrentHashMap = " +totalC+".ms");
    }
}

源码分析

1、类的继承关系

2、类的属性

sizeCtl： table的初始化和扩容需要用到的变量

-1 代表table正在初始化

N 代表N-1个线程在进行扩容操作

其他情况：

1）如果table未初始化，table表示初始化的大小

2）如果table初始化完成，表示table的容量，默认0.75*table.size

初始化操作在第一次put完成

concurrencyLevel在jdk1.8的意义改变，并不代表当前所允许的并发数，只是 用来sizeCtl大小，在jdk1.8的并发控制针对具体的桶而言，所以有多少个桶就有 多少个并发数

3) 构造函数 只是sizeCtl初始化，表示table初始化大小

  final V putVal(K key, V value, boolean onlyIfAbsent) {
 *         //ConcurrentHashMap中键和值不能为空
 *         if (key == null || value == null) throw new NullPointerException();
 *         int hash = spread(key.hashCode());
 *         int binCount = 0;
 *         for (Node<K,V>[] tab = table;;) {
 *         //无限循环 （多线程环境）
 *             Node<K,V> f; int n, i, fh;
 *             if (tab == null || (n = tab.length) == 0)
 *             //表为空或者表长度为0
 *                 //初始化表
 *                 tab = initTable();
 *             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
 *                 //表不为空，该桶位置为空时
 *                 if (casTabAt(tab, i, null,
 *                              new Node<K,V>(hash, key, value, null)))
 *                     //CAS方式插入一个新的Node
 *                     break;                   // no lock when adding to empty bin
 *             }
 *             else if ((fh = f.hash) == MOVED)
 *                 //该节点的hash值为Moved，说明当前节点是ForwardingNode，意味着有其他线程
 *                 //在进行扩容，则一起进行扩容操作
 *                 tab = helpTransfer(tab, f);
 *             else {
 *                 V oldVal = null;
 *                 synchronized (f) {
 *                     //加锁同步，针对首个节点进行加锁操作
 *                     if (tabAt(tab, i) == f) {
 *                         //找到table表下标为i的节点
 *                         if (fh >= 0) {
 *                             //正常节点
 *                             binCount = 1;
 *                             for (Node<K,V> e = f;; ++binCount) {
 *                             //无线循环 相当于自旋
 *                                 K ek;
 *                                 if (e.hash == hash &&
 *                                     ((ek = e.key) == key ||
 *                                      (ek != null && key.equals(ek)))) {
 *                                     oldVal = e.val;
 *                                     if (!onlyIfAbsent)
 *                                         e.val = value;
 *                                     break;
 *                                 }
 *                                 Node<K,V> pred = e;
 *                                 if ((e = e.next) == null) {
 *                                     //遍历至最后一个节点
 *                                     pred.next = new Node<K,V>(hash, key,
 *                                                               value, null);
 *                                     //尾插法插入一个新节点
 *                                     break;
 *                                 }
 *                             }
 *                         }
 *                         else if (f instanceof TreeBin) {
 *                             //判断节点类型是否是红黑树类型
 *                             Node<K,V> p;
 *                             binCount = 2;
 *                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
 *                                                            value)) != null) {
 *                                 oldVal = p.val;
 *                                 if (!onlyIfAbsent)
 *                                     p.val = value;
 *                             }
 *                         }
 *                     }
 *                 }
 *                 if (binCount != 0) {
 *                     if (binCount >= TREEIFY_THRESHOLD)
 *                         treeifyBin(tab, i);
 *                     if (oldVal != null)
 *                         return oldVal;
 *                     break;
 *                 }
 *             }
 *         }
 *         //增加binCount容量，检查当前容量是否需要进行扩容
 *         addCount(1L, binCount);
 *         return null;
 *     }