ConCurrentHashMap高频面试题

由于面试大厂被吊打，我终于下定决心来深深补一下

jdk1.7是sagment分段式锁实现的 1.8就没有了sagment

大概说一下putValue的流程：

1. 判断key是否没空 空就抛出空指针

2. 得到table数组

3. 判断table是否为空，空的话就进行扩容

4. 判断key的哈希值对应table下标是否为空，空的话通过cas操作创建一个node放入table中，然后直接退出。

5. 如果桶位为空，判断当前头节点的返回值是否为-1，如果是则需要当前线程帮助扩容，并得到扩容后的桶，再重新开始循环。

6. 如果桶位为空，并且并不是在进行扩容，并且table上面有其他node存在。声明一个空的value等会进行赋值返回。

7. 把这个找到的node加上同步锁，防止出现并发问题，其他线程进入就进行阻塞。

8. 再次使用cas确认索引上的table为我们的node，如果不是的话，这个node就被修改，直接释放进入下一个循环。

9. 如果目标table的的第一个hash值大于等于0，则判断当前是链式结构，反之为红黑树

10. 标识bincount为1，因为在table上至少有一个node 才会进入链表

11. 进行循环链表

12. 如果遍历元素的哈希值与需要插入目标key的哈希值相同（与hashmap相同的比较方式），并且值也相同，则插入的是重复的key。

13. 判断onlyIfAbsent是否为false 进行替换值，否则就不修改，跳出当前循环。

14. 循环到最后没有相同的key，则直接进行尾插法，也跳出当前循环

15. 如果是红黑树进行红黑树的相关操作

16. 判断链表长度binCount 大于8时，进行红黑树转化，

17. 返回旧的value

18. addCount(1L, binCount);进行扩容判断。

变量名称    含义
bincount    table里目标索引链表的元素个数
f   table里目标索引对应链表的头结点
n   table的长度
i   目标索引
fh  头结点f的哈希值
tab table数组的副本
    
final V putVal(K key, V value, boolean onlyIfAbsent) {
        //1、判断key是否为空
        if (key == null || value == null) throw new NullPointerException();
        //2、计算哈希值
        int hash = spread(key.hashCode());
        int binCount = 0;
        //3、得到table的数组
        for (Node<K,V>[] tab = table;;) {
 
            Node<K,V> f; int n, i, fh;
            //4.如果table数组为空，则初始化table
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            //5.如果对应key的哈希值上对应table数组下标的位置没有node，则通过cas操作创建一个node放入table中,然后putval出栈
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            //6、如果table正在扩容，则得到扩容后的table，然后再重新开始一个循环
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                //7.到这里说明找到了key hash后对应的table，并且table上有其他node的存在
                V oldVal = null;
                //8、把这个找到的node加上同步锁，防止并发出现的问题，如果其他key put进来的时候也对应这个tab则堵塞在这里
                synchronized (f) {
                    //9.再次用cas确认索引i上的table为我们找到的node，如果不是的话则这个node被修改，直接释放锁进入下一个循环
                    if (tabAt(tab, i) == f) {
                        //10.如果目标table的第一个node的哈希值大于等于0，则是链式结构，走链表查找，反之走红黑树查找
                        if (fh >= 0) {
                            //11.标志bincount为1，因为在该table上至少有一个node节点
                            binCount = 1;
                            //12.循环链表
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                //13.如果遍历元素的哈希值与需要插入目标key的哈希值相同，并且值也相同，则插入的是重复key的元素
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    //14.如果onlyIfAbsent为false的话，则替换为新value，否则不修改（一般传false）
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    //15.break循环
                                    break;
                                }
                                //16.循环直到最后一个node节点的key都不是我们想要插入的key
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    //在尾部添加一个新节点，break循环
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        //17.该节点属于红黑树的子节点，进行树操作
                        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;
                            }
                        }
                    }
                }
                //18.如果node节点不为0
                if (binCount != 0) {
                    //19.如果node大于或者等于8，则转为红黑树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    //20.返回原来key对应的旧值
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        //20.进行扩容判断
        addCount(1L, binCount);
        return null;
    }
​

ConcurrentHashmap的负载因子可以指定嘛？

hashmap的负载因子可以指定 （虽然也是final修饰的，但是修改的是负载因子的指向内容），并发map不可以指定因为是final修饰的并且是私有的。

sizeCtl

Node.hash字段一般情况下必须>=0

因为负数是由特殊意义 ForwardingNode节点 是-1 散列表在扩容的时候，会触发一个迁移数据的过程 旧的散列表迁移完了一个桶，有一个标记点ForwardingNode 值是-1

还有一个红黑树的情况，红黑树由一个特殊的节点来代理是TreeBin结构，它本身也是继承Node，它的hash值是-2

ReservationNode 是一个保留节点，就是个占位符，不会保存实际的数据，正常情况是不会出现的 默认的hash值为-3

sizeCtl：

有以下这几种情况：

值为-1：表示正在进行数组初始化

值为0：表示数组未初始化，且数组初始容量为16

值为正数：如果数组未初始化，记录数组的初始容量，如果以及初始化，记录数组的扩容阈值

小于0但是不是-1 表示数组正在扩容，一个扩容状态，高16位表示扩容标识戳，低16位表示线程数量+1， -（1+n）表示有n个线程正在共同完成扩容操作。也就是低16位减1等于现在正在扩容的线程数量。

扩容标识戳：每个线程计算出来的扩容标识戳必须是一致的才能进行并发扩容。这个戳跟扩容之前的表大小是有关系的。

ConcurrenHahMap是怎么保证写数据安全的？

内部通过自旋锁+cas+sunchronized+分段锁来保证线程安全的。

1. 先判断散链表是否已经初始化，如果没初始化则先初始化散链表，再进行写入操作

   

2. 向桶中加入数据，需要先判断桶中知否为空，如果为空就通过cas算法将新增数据添加到桶中。如果写入失败，说明其他线程已经在当前桶位中写入了数据，当前线程竞争失败，回到自旋位置，进行等待。

   

3. 如果桶中不为空，就需要判断当前桶中头节点的类型： 如果桶中头节点值为 -1 表示当前桶位的头节点为fed节点，目前散链表正处于扩容状态，这时候当前线程需要协助扩容。

   

   如果2.3条件都不满足，则表示当前桶位的存放可能是一条散链表，也可能是红黑树的代理对象TreeBin 这种情况下会使用synchronized锁住桶中的头节点，来保证桶内的写操作是线程安全的。

寻址算法

（length-1）& hash 与hashMap相差不大，基本算法就是高16位与这个低16位进行异或运算，但是要强制将符号位变为0，使这个值为正数。因为length一定是2的次方，所以length-1 转换成二进制一定是这种111..的形式，这种数字与任何数字进行按位与运算都一定能得到大于等于0 小于的数。

问在hashMap中 统计当前散列数据量的字段时int类型的size字段，在并发map中是什么呢？

实际上是一个LongAdder（jdk8新特性），但在这个map中名没有直接将这个LongAdder导进来，而是将源码拿过来了，

为什么不采用AtomicLong这种类型

AtomicLong 是基于 CAS 方式自旋更新的；LongAdder 是把 value 分成若干cell，并发量低的时 候，直接 CAS 更新值，成功即结束。并发量高的情况，CAS更新某个cell值和需要时对cell数据扩 容，成功结束；更新失败自旋 CAS 更新 cell值。取值的时候，调用 sum() 方法进行每个cell累加。

AtomicLong 包含有原子性的读、写结合的api；LongAdder 没有原子性的读、写结合的api，能 保证结果最终一致性。低并发场景AtomicLong 和 LongAdder 性能相似，高并发场景 LongAdder 性能优于 AtomicLong。主要还是一个性能的考虑。

注：说一个场景，我们 100个线程的让AtomicLong去自增，cas首先式比较期望值，期望值与实际值一致的时候，才进行替换操作，cas反映到内核层就是cmpxchg指令，在执行时会检查当前平台是否是多核平台，如果是多核，cmpxchg会通过锁总线程的形式来保证同一时刻只有一颗cpu去执行，这100个线程反映到平台上仍然是串行通过的。在后面的线程拿到的期望值已经属于过期数据了，与实际值不一致，就失败了，失败后，再去读内存中的最新值作为期望值，再尝试修改，直到成功为止，每一次只能有一个成功，那么其他线程占用的cpu内存就太大了。

LongAdder 是将值拆分成若干个，就是一种分段式锁，是一种以空间换时间的做法。

触发扩容条件的线程，还需要做那些额外是事？

1 修改sizeCtl 小于0 -1时表示线程正在初始化，或者正在扩容，既然是触发本次扩容线程，那么当前线程就必须去修改sizeCtl。

2 这个线程会创建一个新的table 大小就是旧的两倍。并且告诉新表的引用地址到map.nextTable字段（需要让后续协助扩容的线程直到老表的数据迁移到哪），

3 保存老表的长度到map.transferIndex字段，记录老表的迁移进度。迁移工作进度是从 高位桶开始，一直迁移到下标是 0 的桶位。

迁移完了如何标记？

迁移的时候会创建一个ForwardingNode对象，就是用来表示指定Slot已经被迁移完毕的。

提供了一个用于向新散链表中查询目标数据的find（）方法

其中有一个指向新表的指针nextTable .

散列表正在进行扩容，再有写的请求该如何处理？

执行写入操作的时候，如果访问到桶中不是fwd节点，直接进行写入操作。

如果是fwd节点，表示当前桶中的数据已经被迁移了，也说明此时散链表正在进行扩容，这时候需要当前线程也加入进去（helpTransfer(tab, f);），目的是，为了尽量减少扩容所花的时间。当前线程加入进去后，ConcurrentHashMap 会根据全局的transferIndex字段去分配迁移工作（工作是指，负责迁移旧散链表的桶位区间）。例如负责【0-5】的桶位数据到新的散链表。

如果线程分配不到负责迁移的任务上，就退出协助。即扩容结束后，当前线程就可以继续执行写入的操作了。

扩容期间，扩容工作线程如何维护sizeCtl的低16位呢

前面我们提到，sizeCtl的低16位减一即为线程的个数，一个线程加入扩容，那么就会让低16位+1。

每个执行扩容操作的线程都会被分配到一个迁移工作区间，如果当前线程所负责的任务区间迁移工作完成了，当前线程就可以退出协助扩容了，这时候更新sizeCtl的低16位，让它-1 ，表示一个线程退出了协助扩容。

如果 sizeCtl低 16 位-1后的值为 1，则说明当前线程是最后一个退出并发扩容的线程。

最后一个线程退出前还会遍历一下老表，是否有迁移的遗漏，判断条件就是slot的值是不是fwd节点，将新的引用保存到map.table();字段上，再根据新表的长度算出阈值，保存到sizeCtl字段上。

当桶位中链表升级为红黑树，且当前红黑树上有读线程正在访问，那么如果再来新的写线程请求该怎么处理？

写线程会被阻塞，因为红黑树在写数据的时候，红黑树会触发自平衡，左旋右旋嘛，这就导致了树的结构发生了变化，肯定会影响读线程的读取结果。

static final class TreeBin<K,V> extends Node<K,V> {
        //红黑树 根节点
        TreeNode<K,V> root;
        //链表的头节点
        volatile TreeNode<K,V> first;
        //等待者线程（当前lockState是读锁状态）
        volatile Thread waiter;
        /**
         * 1.写锁状态 写是独占状态，以散列表来看，真正进入到TreeBin中的写线程 同一时刻 只有一个线程。 1
         * 2.读锁状态 读锁是共享，同一时刻可以有多个线程 同时进入到 TreeBin对象中获取数据。 每一个线程 都会给 lockStat + 4
         * 3.等待者状态（写线程在等待），当TreeBin中有读线程目前正在读取数据时，写线程无法修改数据，那么就将lockState的最低2位 设置为 0b 10
         */
        volatile int lockState;
​
        // values for lockState
        static final int WRITER = 1; // set while holding write lock
        static final int WAITER = 2; // set when waiting for write lock
        static final int READER = 4; // increment value for setting read lock
​

在红黑树上读取数据和写入数据是互斥的

在treeBin中有一个lockState字段，线程读取数据时，会使用CAS将它+4（表示加了读锁），读取完毕后，再使用CAS将satte-4。

在进行写操作时，会先检查state的值是否等于0，如果时0，说明没有线程在检索，这时候可以进行写数据，写线程也会通过CAS方式将state字段设置为1 表示加了写锁（独占锁）。

如果state不是0，就会使用park（）挂起当前线程，写线程会先将state的第2个bit位设置位1 就是 2 ，表示有写线程等待被唤醒。读线程结束的时候就会 -4 读线程都再检查state是否为2 如果是，这个读线程就会使用unpark（）接口将等待写线程唤醒.

当红黑树上有写线程正在执行写操作，那么如果有新的读线程请求怎么办？

TreeBin对象内部保留了一个链表结构，这就是为了这种情况而设计的，这时候会让新来的读线程到链表上去访问数据，而不经过红黑树。first就是保留的链表结构，就是专门为了这种情况设计的直接可以检索数据，而不进入红黑树。