ConcurrentHashMap面试大总结

底层数据结构

JDK7

在JDK1.7中ConcurrentHashMap采用了数组+Segment+分段锁的方式实现。

分段锁

ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表,同时又是一个ReentrantLock（Segment继承了ReentrantLock）。

内部结构

ConcurrentHashMap使用分段锁技术，将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，能够实现真正的并发访问。如下图是ConcurrentHashMap的内部结构图：

从上面的结构我们可以了解到，ConcurrentHashMap定位一个元素的过程需要进行两次Hash操作。
第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部。

该结构的优劣势

坏处

这一种结构的带来的副作用是Hash的过程要比普通的HashMap要长

好处

写操作的时候可以只对元素所在的Segment进行加锁即可，不会影响到其他的Segment，这样，在最理想的情况下，ConcurrentHashMap可以最高同时支持Segment数量大小的写操作（刚好这些写操作都非常平均地分布在所有的Segment上）。

所以，通过这一种结构，ConcurrentHashMap的并发能力可以大大的提高

JDK8

利用 CAS + synchronized 来保证并发更新的安全
底层使用数组+链表+红黑树来实现

ConcurrentHashMap的put操作

JDK7

  public V put(K key, V value) {

        Segment<K,V> s;

        if (value == null)
            throw new NullPointerException();
        // 计算key的hash值
        int hash = hash(key);

        // 将hash值右移偏移量位,并与上31(11111),所以j为0-31之间的数
        int j = (hash >>> segmentShift) & segmentMask;

        //定位到段，ConcurrentHashMap不同于HashMap，它既不允许Key值为Null
        //也不允许value值为null，
        //根据key的hash值的高n位就可以确定元素到底在哪一个Segment中
        //紧接着调用这个段的put()方法来将目标key/value对插入到段中
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            // 获取下标为j的segment的对象,如果未创建则用UNSAFE提供的CAS操作创建segment对象。并保证多个线程同时创建的正确性。
           //我们从ConcurrentHashMap的构造函数可以发现Segment数组只初始化了Segment[0]，
            //其余的Segment是用到了延迟加载的策略，而延迟加载调用的就是ensureSegment(J)
            s = ensureSegment(j);

        //对对应段插入数据
        return s.put(key, hash, value, false);
    }


  final V put(K key, int hash, V value, boolean onlyIfAbsent) {

            //获得锁
            /**
             * 。需要注意的是，这里的加锁操作是针对某个具体的Segment，
             * 锁定的也是该Segment而不是整个ConcurrentHashMap。
             * 因为插入键/值对操作只是在这个Segment包含的某个桶中完成，不需要锁定整个ConcurrentHashMap。
             * 因此，其他写线程对另外15个Segment的加锁并不会因为当前线程对这个Segment的加锁而阻塞。
             *
             * 相比于HashTable和由同步器包装的HashMap每次只能有一个线程执行读或写操作，
             * ConcurrentHashMap在并发访问性能上有了质的提高。在理想状态下，ConcurrentHashMap可以支持16个线程执行并发写操作（如果并发级别设置为16）
             *
             *
             */
            //尝试获取锁,获取不到时,调用scan..预先创建节点并返回(有点自旋锁的意味)。
            HashEntry<K,V> node = tryLock() ? null :
                    //  在不超过最大重试次数MAX_SCAN_RETRIES通过CAS尝试获取锁

            scanAndLockForPut(key, hash, value);


            //旧的值
            V oldValue;

            try {

                HashEntry<K,V>[] tab = table;//获得table

                //计算此key在HashEntry[]数组的下标
                int index = (tab.length - 1) & hash;//计算索引位置

                //                // 获取该下标下链表的头节点
                HashEntry<K,V> first = entryAt(tab, index);//first指向桶中链表的表头


                //                // 遍历链表
                for (HashEntry<K,V> e = first;;) {///此处有链表结构，一直循环到e==null
                    if (e != null) { //e不为空
                        K k;
                        if ((k = e.key) == key ||  //找到
                            (e.hash == hash && key.equals(k))) {//找到相同的节点，则替换
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;//不断向后遍历
                    }
                    else { 	//node不为null,设置node的next为first，node为当前链表的头节点
                        if (node != null)
                            node.setNext(first);
                        else//node为null,创建头节点,指定next为first，node为当前链表的头节点
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;                        //大于阈值则需要进行扩容
                        //扩容条件 (1)entry数量大于阈值 (2) 当前数组tab长度小于最大容量。满足以上条件就扩容
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)

                            //ConcurrentHashMap的重哈希实际上是对ConcurrentHashMap的某个端的冲哈喜
                            //因此ConcurrentHash的每个段锁包含的桶为自然也就不进相同
                            rehash(node);

                        else
                            //tab的index位置设置为node,
                            setEntryAt(tab, index, node);

                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();//释放锁
            }

            return oldValue;
        }

JDK8

假设table已经初始化完成，put操作采用CAS+synchronized实现并发插入或更新操作：

• 当前bucket为空时，使用CAS操作，将Node放入对应的bucket中。
• 出现hash冲突，则采用synchronized关键字。倘若当前hash对应的节点是链表的头节点，遍历链表，若找到对应的node节点，则修改node节点的val，否则在链表末尾添加node节点；倘若当前节点是红黑树的根节点，在树结构上遍历元素，更新或增加节点。
• 倘若当前map正在扩容f.hash == MOVED， 则跟其他线程一起进行扩容

ConcurrentHashMap为什么不需要加锁？

JDK7

JDK8

table数组是被volatile关键字修饰的，这就代表我们不需要担心table数组的线程可见性问题，也就没有必要再加锁来实现并发了。

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next; //volitale修饰，内存可见性

//底层数组
 transient volatile Node<K,V>[] table;

JDK7与JDK8对比

项目	JDK1.7	JDK1.8
概览
同步机制	分段锁，每个segment继承ReentrantLock	CAS + synchronized保证并发更新
存储结构	数组+链表	数组+链表+红黑树
键值对	HashEntry	Node
put操作	多个线程同时竞争获取同一个segment锁，获取成功的线程更新map；失败的线程尝试多次获取锁仍未成功，则挂起线程，等待释放锁	访问相应的bucket时，使用sychronizeded关键字，防止多个线程同时操作同一个bucket，如果该节点的hash不小于0，则遍历链表更新节点或插入新节点；如果该节点是TreeBin类型的节点，说明是红黑树结构，则通过putTreeVal方法往红黑树中插入节点；更新了节点数量，还要考虑扩容和链表转红黑树
size实现	统计每个Segment对象中的元素个数，然后进行累加，但是这种方式计算出来的结果并不一样的准确的。先采用不加锁的方式，连续计算元素的个数，最多计算3次：如果前后两次计算结果相同，则说明计算出来的元素个数是准确的；如果前后两次计算结果都不同，则给每个Segment进行加锁，再计算一次元素的个数；	通过累加baseCount和CounterCell数组中的数量，即可得到元素的总个数；
锁的粒度	原来是对需要进行数据操作的Segment加锁	现调整为对每个数组元素加锁（Node）