HashMap和ConcurrentHashMap区别看完没人能难住你

关于HashMap与ConcurrentHashMap的的区别，在面试的时候基本都会被问到，所以下面我们就来谈谈相关知识点：

一、HashMap概述

本质浅谈

HashMap是基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap类与Hashtable大致相同。）Hashmap本质是数组加链表。根据key取得hash值，然后计算出数组下标，如果多个key对应到同一个下标，就用链表串起来，新插入的在前面。

还有一点需要注意，就是HashMap不是线程安全的，如果想要线程安全的HashMap，可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap.

HashMap的数据结构

HashMap的底层主要是基于数组和链表来实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置，能够很快的计算出对象所存储的位置。HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。如果存储的对象对多了，就有可能不同的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。学过数据结构的同学都知道，解决hash冲突的方法有很多，HashMap底层是通过链表来解决hash冲突的。

从上图中可以看出，HashMap底层就是一个数组结构，数组中存放的是一个Entry对象，如果产生的hash冲突，也就是说要存储的那个位置上面已经存储了对象了，这时候该位置存储的就是一个链表了。我们看看HashMap中Entry类的代码：

 static class Entry implements Map.Entry {
          final K key;
          V value;
          Entry next;
          final int hash;
  
          /**
           * Creates new entry.
           */
         Entry(int h, K k, V v, Entry n) {
             value = v;
             next = n; //hash值冲突后存放在链表的下一个
             key = k;
             hash = h;
         }
 
         .........
     }

HashMap其实就是一个Entry数组，Entry对象中包含了键和值，其中next也是一个Entry对象，它就是用来处理hash冲突的，形成一个链表。

HashMap的初始化

HashMap有两个参数会影响其性能，初始容量和加载因子：容量是HashMap在创建时“桶”的数量，而初始容量是哈希表在创建时分配的空间大小。加载因子是哈希表在其容量自动增加时能达到多满的衡量尺度（比如默认为0.75，即桶中数据达到3/4就不能再放数据了）。如果加载因子过大，迭代性能会下降，虽然空间开销减少。如果初始容量小于最大条目数除以加载因子，则会发生 rehash 操作。rehash操作即重建内部数据结构，一般是增加桶数为原来的两倍，rehash过程中会重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

当我们使用HashMap(int initialCapacity)来初始化容量的时候，jdk会默认帮我们计算一个相对合理的值当做初始容量。但是这个值并没有参考loadFactor的值。也就是说，如果我们设置的默认值是7，经过JDK处理之后，会被设置成8，但是，这个HashMap在元素个数达到 8*0.75 = 6的时候就会进行一次扩容，这明显是我们不希望见到的。如果我们通过expectedSize / 0.75F + 1.0F计算，7/0.75 + 1 = 10 ,10经过JDK处理之后，会被设置成16，这就大大的减少了扩容的几率。扩容的过程是比较耗费时间的，所以初始化容量要设置成expectedSize/0.75 + 1的话，可以有效的减少冲突也可以减小误差。当然，把默认容量设置成expectedSize / 0.75F + 1.0F 是一个在性能上相对好的选择，但是，同时也会牺牲些内存。

二、ConcurrentHashMap概述

本质浅谈

为什么要使用ConcurrentHashMap

在并发编程中,jdk1.7的情况下使用 HashMap 可能造成死循环，而jdk1.8 中有可能会造成数据丢失

ConcurrentHashMap：在hashMap的基础上，ConcurrentHashMap将数据分为多个segment(段)，默认16个（concurrency level），然后每次操作对一个segment(段)加锁，避免多线程锁的几率，提高并发效率。

ConcurrentHashMap结构

jdk1.7中结构

jdk1.7中采用Segment+HashEntry的方式进行实现，采取分段锁来保证安全性。Segment 扮演锁的角色，HashEntry 则用于存储键值对数据。一个 ConcurrentHashMap 里包含一个 Segment 数组，一个 Segment 里包含一个 HashEntry 数组，Segment 的结构和 HashMap 类似，是一个数组和链表结构。

jdk1.8中结构

JDK1.8 的实现已经摒弃了 Segment 的概念，而是直接用Node 数组+链表+红黑树的数据结构来实现，并发控制使用Synchronized 和 CAS来操作，整个看起来就像是优化过且线程安全的 HashMap，虽然在 JDK1.8 中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本。

ConcurrentHashMap的初始化

1.7中实现

ConcurrentHashMap 的初始化是通过位运算来初始化 Segment 的大小的(ssize 表示)

通过concurrentLevel 计算得出。

  int sshift = 0;
  int ssize = 1;
while (ssize < concurrencyLevel) {
    ++sshift;
    ssize <<= 1;
}

ssize 用位于运算来计算（ssize <<=1），所以 Segment 的大小取值都是以2的N次方,Segment 的大小 ssize 默认为16.
每一个 Segment 元素下的 HashEntry 的初始化也是按照位于运算来计算，用 cap 来表示

  int cap = 1;
while (cap < c)
    cap <<= 1;

HashEntry 大小的计算也是2的N次方（cap <<=1）， cap 的初始值为1，所以 HashEntry 最小的容量为2.
根据SegmentShift和SegmentMask定位到哪个Segment

1.8中的实现

table: 默认为null，初始化发生在第一次插入操作，默认大小为16的数组，用来存储Node节点数据，扩容时大小总是2的幂次方。

nextTable: 默认为null，扩容时新生成的数组，其大小为原数组的两倍

Node:保存 key，value 及 key 的 hash 值的数据结构。

table 初始化

实例化 ConcurrentHashMap 时带参数时，会根据参数调整 table 的大小，假设参数为 100，最终会调整成 256，确保 table 的大小总是2的幂次方.

private final Node[] initTable() {
    Node[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        //如果一个线程发现sizeCtl<0，意味着另外的线程执行CAS操作成功，当前线程只需要让出cpu时间片
        if ((sc = sizeCtl) < 0) 
            //其他线程cas失败,再次进入循环时,发现SIZECTL为-1,谦让出cpu
            Thread.yield(); 
        //cas将SIZECTL设置为-1
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node[] nt = (Node[])new Node[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

三、HashMap与ConcurrenHashMap区别总结

HashMap

• 底层数组+链表实现，可以存储null键和null值，线程不安全

• 初始size为1****6，扩容：newsize = oldsize*2，size一定为2的n次幂

• 扩容针对整个Map，每次扩容时，原来数组中的元素依次重新计算存放位置，并重新插入

• 插入元素后才判断该不该扩容，有可能无效扩容（插入后如果扩容，如果没有再次插入，就会产生无效扩容）

• 当Map中元素总数超过Entry数组的75%，触发扩容操作，为了减少链表长度，元素分配更均匀

• 计算index方法：index = hash & (tab.length – 1)

HashMap的初始值还要考虑加载因子:

• 哈希冲突：若干Key的哈希值按数组大小取模后，如果落在同一个数组下标上，将组成一条Entry链，对Key的查找需要遍历Entry链上的每个元素执行equals()比较。
• 加载因子：为了降低哈希冲突的概率，默认当HashMap中的键值对达到数组大小的75%时，即会触发扩容。因此，如果预估容量是100，即需要设定100/0.75＝134的数组大小。
• 空间换时间*：如果希望加快Key查找的时间，还可以进一步降低加载因子，加大初始大小，以降低哈希冲突的概率。*

ConcurrentHashMap

• 底层采用分段的数组+链表实现，线程安全

• 通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)

• Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术

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

• 扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容

ConcurrentHashMap是使用了锁分段技术来保证线程安全的。

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

ConcurrentHashMap提供了与Hashtable和SynchronizedMap不同的锁机制。Hashtable中采用的锁机制是一次锁住整个hash表，从而在同一时刻只能由一个线程对其进行操作；而ConcurrentHashMap中则是一次锁住一个桶。

ConcurrentHashMap默认将hash表分为16个桶，诸如get、put、remove等常用操作只锁住当前需要用到的桶。这样，原来只能一个线程进入，现在却能同时有16个写线程执行，并发性能的提升是显而易见的。