概念

java5开始才有的并发类，可以高效地支持并发操作。基本上就是个线程安全版的HashMap。但是key和value都不能为null，这点和HashMap不同

基本结构

java8之前

Segment数组+HashEntry数组+链表结构

它由一个个Segment组成，Segment就是我们说的分段锁，一个HashEntry数组对应一个分段锁

简单说，ConcurrentHashMap就是一个Segment数组，Segment通过继承ReentrantLock来加锁，每次需要加锁的操作，锁住的是一个Segment，这样只要保证每个Segment线程都安全，也就保证了全局是线程安全的

如下图

注意: 初始化后Segment数组是无法扩容的，能扩容的只有HashEntry数组。如果初始化时候，没有指定segment数组长度，默认为16。如果指定长度，则使用指定长度

基本属性源码

/**
 * 段掩码，用于定位段，默认值15，不可变
 */
final int segmentMask;

/**
 * 段偏移量，用于定位段，默认值28，不可变
 */
final int segmentShift;

/**
 * 段数组
 */
final Segment<K,V>[] segments;

static final class Segment<K,V> extends ReentrantLock implements Serializable {
    /**
     * 真正存储数据的数组
     */
    transient volatile HashEntry<K,V>[] table;

    /**
     * 用于统计当前Segement大小，即HashEntry数组长度
     */
    transient int count;

    /**
     * 记录结构性修改次数，用于快速失败
     */
    transient int modCount;

    /**
     * 阈值
     */
    transient int threshold;

    /**
     * 负载因子，默认 0.75
     */
    final float loadFactor;
}

static final class HashEntry<K,V> {
    //节点hash值
    final int hash;
    //节点key值
    final K key;
    //节点value值
    volatile V value;
    //下个节点引用
    volatile HashEntry<K,V> next;
}

从以上代码可知，一个Segment就是一个HashMap，多个HashMap组成一个ConcurrentHashMap。segmentMask和segmentShift组合起来用于定位Segment数组的下标位置

由于目前java已发展到14版本，因此对于java8之前的版本，ConcurrentHashMap操作只做文字说明，有兴趣的可自行查看java7等8之前的版本源码

put操作

计算待put数据key的hash值
根据hash值、segmentShift和segmentMask通过无符号右移运算和位运算定位到哪个Segment，一个 Segment对应一个HashEntry数组
尝试获取锁，如果获取失败则自旋获取锁
根据hash值通过位运算得到HashEntry数组的下标，即得到链表的头节点，然后遍历链表
如果链表不为空，判断传入的key和hash值与当前遍历的key和hash值是否相等，相等则覆盖旧的value
如果链表为空（即表头为空），则根据待put数据的key和value创建结点，即初始化链表
判断元素个数是否超过阈值，数组长度大于阈值threshold且小于最大容量，则进行rehash扩容
如果不需扩容，则把新节点放到HashEntry数组中对应的位置（即把新的节点设置成原链表的表头，头插法）
最后释放锁

get操作

计算get数据key的hash值
根据hash值、segmentShift和segmentMask通过无符号右移运算和位运算定位到哪个Segment，一个 Segment对应一个HashEntry数组
根据hash值通过位运算得到HashEntry数组下标，即得到链表的头节点，然后遍历链表
判断传入的key和hash值与当前遍历的key和hash值是否相等，相等则返回对应value，否则返回null

扩容操作

创建新HashEntry数组，数组长度是原来的2倍，重新计算新的阈值
遍历旧数组，把每个元素（即HashEntry链表）迁移到新数组里面，步骤如下
如果旧数组只有一个结点，则直接放入新数组中
如果链表有多个结点，遍历旧链表，计算存放在新数组中的位置，使用头插法插入到新数组，即旧链表的表头结点做为新链表的尾结点
迁移完成之后将待新增数据插入链表的头部（头插法），最后将新数组的引用替换旧的

从java8开始及之后版本

几个变化

使用Node数组作为数据的基本存储。但锁粒度被缩小到数组中的每个下标位置上，数据读取的可见性依靠volatile来保证。尝试写入时，会将对应的下标位置上的元素作为加锁对象，使用synchronized进行加锁，来保证并发写入的安全性
如果多个Key的hashcode在取模后落在了相同的下标位置上，且在一定数量内（默认是8），采用链表方式连接节点；超过之后，为提高查询效率，会转为红黑树结构进行存储（和HashMap一样树化成红黑树）
当进行扩容时，除了扩容线程本身，如果其他线程识别到扩容正在进行中，则会尝试协助扩容

和java8之后的HashMap相同点

底层数据结构一致（数组+链表+红黑树）
数组初始化都是在第一次put元素时进行，而不是new对象时候
数组长度都总是为2的幂
默认树化的阈值为8，而退化为链表的阈值为6
hash算法也很类似，ConcurrentHashMap也是key的hashCode值右移16位和原值取异或。但多了一步，和 HASH_BITS取与，这是是为了消除最高位上的负符号，hash的负值在ConcurrentHashMap中有特殊意义表示在扩容或者是树节点(下文都会提及)

下面从源码角度说明几个操作(java11版本)

put操作

    static final int TREEIFY_THRESHOLD = 8;
    
    public V put(K key, V value) {
        return putVal(key, value, false);
    }

    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        //1.使用spread方法得到key的hash
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh; K fk; V fv;
            //2.第一次调用put时才调用initTable方法来初始化Node数组
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            //3.如果相应位置的Node节点还未初始化，则通过CAS插入相应的数据
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                    break; // no lock when adding to empty bin
            }
            //4.如果对应Node不为空，且其hash标识为特定负数，也就是标识容器正在扩容的负数，此时需协助扩容
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else if (onlyIfAbsent // check first node without acquiring lock
                     && fh == hash
                     && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                     && (fv = f.val) != null)
                return fv;
            else {
                V oldVal = null;
                //5.执行元素添加
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        //5.1该节点的hash不小于0，则遍历链表更新节点或插入新节点
                        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);
                                    break;
                                }
                            }
                        }
                        //5.2如果是TreeBin类型节点，说明是红黑树，则通过putTreeVal方法往红黑树中插入节点
                        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;
                            }
                        }
                        else if (f instanceof ReservationNode)
                            throw new IllegalStateException("Recursive update");
                    }
                }
                //6.采用链表存储节点，且链表长度超过阀值，则将链表转化为红黑树(树化)
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        //7.容器内元素总数+1，并在需要时执行扩容
        addCount(1L, binCount);
        return null;
    }

使用spread方法得到key的hash

源码

    static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
    
    static final int spread(int h) {
        return (h ^ (h >>> 16)) & HASH_BITS;
    }

HASH_BITS值0x7FFFFFFF是一个用16进制表示的整型,是整型里面的最大值转换成二进制0111 1111 1111 1111 1111 1111 1111 1111（前31个1代表数值，最高位（32位）是符号位 0代表正数，1代表负数），hashcode值与其按位与会得到一个正数

尝试添加元素时发现tab为null，则Node数组尚未初始化，此时执行初始化方法initTable

源码

     private transient volatile int sizeCtl;

     private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            else if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

通过CAS争夺sizeCtl属性控制权，成功将该值设置为-1的线程可执行初始化，其他线程通过Thread.yield()进行等待，直到确认容器初始化完毕，也就是tab数组有了值。初始化完毕时，sizeCtl被设置为下一次扩容的容量阀值，该值为当前容量的0.75（见源码，n为当前容量值。当变量n右移2位，2的-2次方变为0.25n，然后n减去0.25n为0.75n）

虽然已经初始化了Node数组，但是Key的hash对应的下标位置的节点元素为空，则新建一个Node节点放入该下标位置数组中

源码

   static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectAcquire(tab, ((long)i << ASHIFT) + ABASE);
   }
    
   static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSetObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
   }

tabAt方法通过计算对应下标位置在数组中的偏移量值，即((long)i << ASHIFT) + ABASE，基础偏移量+元素间隔偏移量。且读取时使用的是getObjectVolatile方法，该方法的读取和对属性使用volatile是一样效果，保证读取到最新值

casTabAt方法在下标位置的节点元素为空时，写入采用了compareAndSetObject方法，目的也是为了保证并发安全性。若CAS成功，则元素添加完毕，可以直接退出循环。若失败，则意味着有其他线程已经对相同的下标位置操作成功，此时就要重新循环，确认最新情况，就是步骤4

对应Node不为空，且其hash标识为特定负数，也就是标识容器正在扩容的负数MOVED，此时需要协助进行容器扩容

由于key的hash会经过方法spread处理，因此必然为正数。而负数的hash有三个特殊的含义(源码中有定义，见下)

-1: 代表容器正在扩容，且当前节点数据已前移到扩容后的数组中
-2: 代表当前下标位置上的Node节点采用红黑树结构存储
-3: 代表该Node节点正在进行函数式运算，值还未最终确定

    static final int MOVED     = -1; // hash for forwarding nodes
    static final int TREEBIN   = -2; // hash for roots of trees
    static final int RESERVED  = -3; // hash for transient reservations

关于扩容和协助扩容，下文会详细记述，这里只需记住协助扩容的触发条件是hash标识为MOVED即可

这里是真正开始执行元素添加的操作，分为两步来说 5.1 节点的hash值不小于0，则遍历链表更新节点或插入新节点。类似HashMap章节所述，判断节点中的key和 value是否和要添加的键值对相同，如果不同就添加到链表尾部（尾插法）。重复，则依据方法入参onlyIfAbsent的值判断是否要进行覆盖 5.2 如果是TreeBin类型节点，说明是红黑树，则通过putTreeVal方法往红黑树中插入节点（红黑树会在之后章节具体说明，这里只需要明白是插入树型节点即可）
采用链表存储节点，且链表长度超过阀值8，则将链表转化为红黑树(树化)。见源码注释6，binCount不为0，说明put操作对数据产生影响，在当前链表个数大于等于阈值8时，通过treeifyBin方法转化为红黑树。接着判断oldVal是否不为空，不为空说明是更新操作，不会让元素个数产生变化，则直接返回旧的value
容器内元素总数+1，并在需要时执行扩容。调用addCount方法尝试更新元素个数baseCount

扩容和协助扩容操作

扩容和协助扩容操作其实就在前述注释7这个addCount方法里，但是这个方法看名字其实是对Node数组的元素个数进行更新操作。所以我先把整个addCount方法源码分析一下

     private final void addCount(long x, int check) {
        CounterCell[] cs; long b, s;
        //1. 元素个数更新
        if ((cs = counterCells) != null ||
            !U.compareAndSetLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            CounterCell c; long v; int m;
            boolean uncontended = true;
            if (cs == null || (m = cs.length - 1) < 0 ||
                (c = cs[ThreadLocalRandom.getProbe() & m]) == null ||
                !(uncontended =
                  U.compareAndSetLong(c, CELLVALUE, v = c.value, v + x))) {
                fullAddCount(x, uncontended);
                return;
            }
            if (check <= 1)
                return;
            s = sumCount();
        }
        //2. 扩容判断，true就开始真正的扩容
        if (check >= 0) {
            Node<K,V>[] tab, nt; int n, sc;
            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                   (n = tab.length) < MAXIMUM_CAPACITY) {
                int rs = resizeStamp(n);// 2.1 计算盖戳标记值
                if (sc < 0) {//2.2 协助扩容
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                        break;
                    if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1))
                        transfer(tab, nt);
                }
                // 2.3 扩容
                else if (U.compareAndSetInt(this, SIZECTL, sc,
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null);
                s = sumCount();
            }
        }
    }

如上源码可知这个addCount方法分为两大部分

整体更新思路实际上和java8新增的一个统计类完全一致的，即java.util.concurrent.atomic.LongAdder。这个类用于在更高的并发竞争下，降低或维持数字计算的延迟。其性能比传统的AtomicLong更好。介绍一下核心思路

整个统计的数据结构包含一个基本的长整形变量baseCount和一个统计单元CounterCell构成的数组，数组长度为2的幂，初始长度为2，最大长度超过CPU内核数时停止扩容
当统计数字需要变化时，优先在baseCount上执行CAS操作。如果成功，意味着更新完成。如果失败，说明此时有多线程竞争，放弃在baseCount上的争夺
当放弃在baseCount上的争夺时，通过线程上的随机数h在CounterCell数组上找到下标位置，在此位置上的CounterCell内部的整型变量上循环执行CAS更新，直到成功
如果需要初始化CounterCell数组或者添加元素到具体下标位置，或者扩容，那就只能一个线程进行，该线程需要对cellBusy这个属性进行CAS争夺并成功

核心思路就是避免多线程在一个变量上循环CAS直到成功。因为当多线程竞争较为激烈时，大量的线程会在不断的 CAS失败中浪费很多CPU时间。通过线程变量的方法，将多线程分散到不同的CounterCell元素中，降低竞争激烈程度和颗粒度，从而提高并发效率。

由于统计数据被分散在baseCount和CounterCell数组中，执行总数计算时也需要遍历这里面所有的值相加才能得到最终值。接着就是扩容判断环节

扩容依据是sizeCtl，当容器元素总数超过sizeCtl时，执行扩容流程(见源码中while循环判断条件)

2.1 对当前数组长度计算盖戳标记值，也就是resizeStamp方法，其具体代码如下

    static final int resizeStamp(int n) {
        return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
    }

注释1中说数组长度n是2的幂，Integer.numberOfLeadingZeros(n)获得32位整型数字中，在第一个1之前有多少个0的结果，因此这个值实际上是数字n的一种换算关系

RESIZE_STAMP_BITS则意味着该结果能够占据的比特位数。由于Integer.numberOfLeadingZeros(n)最大值为27（n的最小值为16），因此RESIZE_STAMP_BITS最小也必须为6。

这个方法计算出来的结果，实际上可看成是数组长度的固定换算值。这个值可在扩容过程用于判断是否扩容完毕

开始判断是执行扩容还是协助扩容操作。如果sizeCtl当前值为负数，就协助扩容也就是注释2.2；如果为正数，就扩容，也就是注释2.3

这里要说明一下sizeCtl

0: 初始值，意味着此时数组尚未初始化
-1: 控制值，意味着有线程取得了数组的初始化权利，并且正在执行初始化中
正数: 要扩容的阀值，一旦元素总数到达该值，则应该进行扩容。除非数组长度到达上限
非-1的负数: 意味着当前数组正在扩容，该值左边RESIZE_STAMP_BITS个数的比特位用于存储数组长度n的盖戳标记，右边32-RESIZE_STAMP_BITS位用于存储当前参与扩容的线程数

2.2 先看源码中第一个if判断 (sc >>> RESIZE_STAMP_SHIFT) != rs意味着数组长度已经发生变化，扩容可能已结束，不需要协助。transferIndex <= 0意味着原始数组已无可分配的扩容区域，不需要协助。 sc == rs + 1 || sc == rs + MAX_RESIZERS这个条件永远不会达成，属于bug。具体可看 https://bugs.java.com/bugdatabase/viewbug.do?bugid=JDK-8214427 (java12版本已修复) 如果确认需要协助，就到第二个if。if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1))通过 CAS增加了一个协助线程数量，然后执行transfer迁移方法

2.3 通过CAS对sizeCtl值进行置换。扩容时需要置换的值含义上面也说过（正数），左边是盖戳标记，右边是参与扩容的线程数

老实说put和扩容以及协助扩容操作代码比较深奥，个人以为面试不会考的这么细致，但是最好记住步骤和这样执行的目的，特别是何时CAS，何时Synchronize以及sizeCtl和计算得出的hash的正负数含义是什么这些

get操作

先看一下get操作源码

    public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        //1.使用spread方法得到key的hash
        int h = spread(key.hashCode());
        //2. 判断数组是否为空，不为空根据hash值确定Node节点位置  
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            //3. 如果搜索到的Node节点key与传入的key相同且不为null,直接返回节点的value
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            //4. 如果eh<0，说明Node节点在红黑树上，直接查询  
            else if (eh < 0)
                return (p = e.find(h, key)) != null ? p.val : null;
            //5. 否则遍历链表，找到对应的值并返回  
            while ((e = e.next) != null) {
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;
    }

和put操作第一步相同，不再记述
先判断tab数组是否为空，不为空再用tabAt方法，根据hash值确定Node节点位置
判断找到的Node节点的hash值是否和key的hash值相同，再判断key相同且不为null，返回该节点的value
eh小于0，则说明节点在红黑树上，去那边查询(红黑树搜索，添加会另外记述，这里不作更多说明)
否则遍历链表，找到对应的Node节点的value

追命三问

ConcurrentHashMap为啥比Collections.synchronizedMap()读写性能更加好？

网上有人做了测试，发现同样进行put，get操作，ConcurrentHashMap性能都比Collections.synchronizedMap()好，那么为啥呢？

put操作 Collections.synchronizedMap()的put封装了HashMap的put方法，并加上互斥锁保证安全性。java8之后的ConcurrentHashMap取消了segments分段锁，采用transient volatile Node<K,V>[] table;保存数据。这样对每个Node数组元素加锁，见put操作源码中synchronized(f)，可减少并发冲突概率，提高并发性能。所以ConcurrentHashMap的put并发性更好
get操作 Collections.synchronizedMap()同样封装了HashMap的get方法并加了同步锁。从前述ConcurrentHashMap的get操作源码可知。get操作全程并没有加锁，所以性能上优于Collections.synchronizedMap()的get方法

那么问题来了

ConcurrentHashMap的get操作为啥不需要加锁？

原因是Node的元素val和指针next是用volatile修饰的，在多线程环境下线程A修改Node结点的val或新增节点时是对线程B可见（volatile关键字描述见并发编程章节）

Node源码中修饰val和next内容如下图红框所示（Node类在ConcurrentHashMap类源码中）

另外有人说还和Node数组被修饰为volatile关键字有关，见下图ConcurrentHashMap类源码中，Node数组定义代码

但其实这是错误的说法，volatile的确可以修饰数组，但修饰的是数组地址。

比如，volatile int myArray[100]是指myArray地址是volatile的而不是数组元素值是volatile

那么问题又来了

ConcurrentHashMap中的Node数组被修饰为volatile的目的是啥？

答案: 为了扩容！！！

当Node数组扩容时，可以对其他线程具有可见性，所以加了volatile

三问答案简易版

java8中的ConcurrentHashMap，它的get操作，全程不需要加锁，这也是比hashtable、用Collections.synchronizedMap()封装的hashmap这些集合类读写性能好的原因之一
get操作全程不需要加锁是因为Node的成员val和指针next是用volatile修饰的。和用volatile修饰的Node数组没关系
数组用volatile修饰主要是为了能在数组扩容时,保证可见性

总结

版本区别

JAVA8之前主要采用锁机制，对某个Segment进行操作时，锁定该Segment，不允许对其进行非查询操作，而JAVA8之后是对每个Node数组中的元素，即Node节点采用CAS无锁算法操作，这种操作在完成前进行判断，如果符合预期结果才给予执行，对并发操作提供了良好的优化

为啥java8开始放弃Segment？

根本原因在于java7中的Segment继承ReentrantLock，使用了显示锁，在其实例方法中，每个更新操作内部又使用Unsafe来处理更新。这显然是一种浪费。显示锁、Unsafe这二者都可保证对对象的原子操作。使用一个就行了。但是java8中，Segment还是予以了保留，仅用来处理对象流的读写

和其它类型的区别

见表格

类名	key	value	父类	是否线程安全
ConcurrentHashMap	不允许为null	不允许为null	AbstractMap	安全
HashMap	允许为null	允许为null	AbstractMap	不安全
TreeMap	不允许为null	允许为null	AbstractMap	不安全
Hashtable	不允许为null	不允许为null	Dictionary	安全

和Hashtable在实现线程安全上的区别

ConcurrentHashMap
java8之前，ConcurrentHashMap对整个数组进行了分段(Segment)，每一把锁只锁其中一部分数据，多线程访问不同数据段的数据，不会存在锁竞争，提高并发访问率。（默认分配16个Segment，比Hashtable效率提高16倍。） java8之后，放弃了Segment，直接用Node数组+链表+红黑树来实现，使用synchronized和CAS来并发控制操作。所以看起来就像是优化过且线程安全的HashMap（这也是为啥一开始就说它是线程安全版的HashMap），虽然在java8中还有Segment数据结构，但已简化了属性，只是为了兼容旧版本见ConcurrentHashMap中的Segment源码及其注释
Hashtable
使用synchronized来保证线程安全，效率非常低下。当多个线程访问同步方法时，可能会进入阻塞或轮询状态，若使用put添加元素，另一个线程则不能使用put添加元素，也不能使用get，竞争越激烈效率越低

参考资料

JDK-8214427: probable bug in logic of ConcurrentHashMap.addCount()

https://bugs.java.com/bugdatabase/viewbug.do?bugid=JDK-8214427