并发编程 - Hash、位运算、HashMap、ConcurrentHashMap

什么是Hash？

Hash，又称之为散列，将一个任意长度的输入通过散列算法之后，变成一个固定的输出，该值也称之为散列值，这种转换也称之为压缩映射。
最常见的散列算法：直接取余法、乘法取整法、平方取中法。
解决hash冲突的方式：开放寻址法（ThreadLocalMap）、再散列、链地址法（HashMap、ConcurrentHashMap）。

十进制与二进制

日常生活中，通过数字计算均采用的十进制来表示，即逢十进一。二进制一般用于计算机操作中，逢二进一。

例如数字：208

十进制表示为：2*100+0*10+8*1，即 208
二进制表示为：1*2⁷ +1*2⁶+0*2⁵+1*2⁴+0*2³+0*2²+0*2¹+0*2⁰，即 11010000

常见的位运算

• 位与（&）： 与&&相似，两者必须为1才为1
• 位或（|） ：与||相似，两者其中一个为1即为1
• 位异或（^） ：只能其中一个为1才为1，否则都为0
• 位非（~）：取反，如果为1，那么为0，相反如果为0，那么为1
• 有符号左移（<< ）：把当前数向正数移动指定位数，低位均补0
• 有符号右移（>>） ：把当前数向负数移动指定位数，如果是正数，高位补0，为负数，高位补1
• 无符号右移（>>>）：无论正负，高位均补0

位与
0 & 1 = 0，1 & 0 = 0 ， 0 & 0 = 0， 1 & 1 = 1
位或
0 & 1 = 1，1 & 0 = 1 ， 0 & 0 = 0， 1 & 1 = 1
位异或
0 & 1 = 1，1 & 0 = 1 ， 0 & 0 = 0， 1 & 1 = 0
位非
~0 = 1，~1 = 0
a%(2ⁿ)等价于a&(2^n-1)

HashMap

• 1.7中死循环的问题
  在多线程环境中，由两个线程同时操作一个map时，当发现数据已经达到阈值时，需要对数组进行扩容操作。
  由于在扩容操作时，两个线程分别进行扩容，当A线程扩容过程中被挂起，而B线程扩容完成之后，A线程再回到扩容时，就会触发队列尾指向了队列头的这种可能性，所以在查询时，当get到一个不存在的值时，就会出现死循环。

ConcurrentHashMap

• 1.7中数据结构为Segment + table+hashEntry。初始化只初始化0的数组。
• • 加锁在Segment数组元素上，采用可重入锁实现。
• • get元素时，通过key计算出hash，将hash的高位用来定位Segment，将hash全部用来定位table，其中value与nextHashEntry均为volatile关键字，所以在get时不需要加锁。
• • put元素时先计算hash（与get一致），先判断Segment是否为null，如果为null，那么进行初始化，使用CAS+自旋进行初始化。然后调用putVal使用tryLock来尝试获取锁，如果拿到了node即为null，否则自旋拿锁（自旋次数与cpu核心数有关，如果cpu核心数大于1，那么就为64次，否则为1次），当次数达到后，使用lock来拿锁。
• • rehash用于对数组进行扩容，当需要扩容时，就会调用此方法，扩容容量为2倍，先创建一个2倍容量的新的table，然后将原table中的数据进行迁移到新table中，并且重新计算hash值。
• • remove 移除链表中元素，找到指定Segment下面的table，然后根据链表找到指定的key，然后将节点从链表中脱离，并将该删除节点的上一个节点与下一个节点进行关联。
• • size用于统计所有Segment下的元素。该方法慎用，因为在size内部会进行两次普通统计，如果两次统计结果一致，那么就会结束并返回，否则会对整个segments进行加锁操作，然后依次统计每个segment的数量并返回。**所以当两次统计结果不一致时，会对整张表进行锁定。**尽量不要在高并发场景使用，如果需要判断整个map是否为空，可以使用isEmpty。
    
• 1.8中数据结构为table+链表+红黑树，初始不对数组进行初始化。
• • 加锁在TreeBin上，使用synchronized实现
• • 转换：当链表长度大于8的时候，转为红黑树，当红黑树小于6的时候，转化成链表。
• • 红黑树节点：存在根节点的是TreeBin，子节点是Tree Node 继承于Node节点，而hashmap的Tree Node是继承于linkedHashMap.Entry。
• ForwardingNode：用于对数组进行扩容，如果该数组的某个元素的根节点为ForwardingNode节点时，代表该节点正在处于扩容操作。
• • sizeCtl：是一个重要的属性，用来控制table的初始化和扩容操作，取值如下：
• • • -1：代表该数组正在初始化
• • • 小于-1：表示当前有多少个线程正在进行扩容操作
• • • 0表示当前table还没有初始化
• • • 大于0：表示当前map的初始化大小，当map的size大小到达了这个值时，就需要进行扩容操作。
• • 核心方法：tabAt，casTabAt，setTabAt。
• • tabAt：用于获取table指定坐标下头结点。
• • casTabAt：用于设置table指定坐标下头节点。
• • setTabAt：用于添加到table指定坐标下元素。
• • get 获取元素，通过tabAt获取到根节点，然后根据根节点的hash（小于0表示红黑树）判断是链表还是红黑树，进行遍历取值。
• • put 添加元素
• • • 如果该数组没有元素，那么使用casTabAt进行设置根节点
• • • 如果发现当前ConcurrentHashMap正在扩容，那么插入元素的线程会帮助进行扩容，扩容完成之后，再进行插入
• • • 锁根节点，如果是链表就按照链表插入到尾部，如果是红黑树那就按照红黑树的方法插入，插入完成之后，检测是否需要从链表转换成红黑树（TREEIFY_THRESHOLD = 8）以及addCount并检查是否需要扩容
• • remove 移除元素
• • • 如果该数组没有元素，那么移除失败
• • • 如果发现当前ConcurrentHashMap正在扩容，那么插入元素的线程会帮助进行扩容，扩容完成之后，再进行插入
• • • 锁根节点，如果是链表就用链表查找法将该元素从链表中脱离，如果是红黑树就采用红黑树的方式将元素从红黑树中脱离，并且检查是否需要从红黑树转换成链表（UNTREEIFY_THRESHOLD = 6）
• • transfer 对map进行扩容，先new出一个两倍大小的数组，然后将原表中链表根节点重新计算hash值，然后该数组下整个链表进行直接迁移，但是红黑树的话，需要重新计算每个TreeNode的hash值，然后再判断该链表是否达到了转换红黑树的条件。同时扩容时有一个stride来记录步长，即当前线程A在对0做扩容，做完后将原表根节点改成Forwardding节点，然后再根据步长（假设为4）再去扩容5的内容，然后再重新计算sizeCtl为原来的0.75倍。
• • treeifyBin 将链表转换成红黑树，其根节点为TreeBin，其余节点为TreeNode
• • size 通过调用SumCount来获得，其size组成由baseCount + CountCell，baseCount记录的是成功的个数，CountCell记录的是失败的个数。因为在put时，可能会有两个线程同时进行累加，如果一个通过cas累加成功，另一个将不会使用循环cas进行累加，而是记录在CountCell里面，所以实际的size是baseCount+CountCell

HashMap与ConCurrentHashMap的区别

• HashMap允许为null的key和value，ConCurrentHashMap都不允许
• 1.7
• • HashMap中数据结构采用了数组+链表
• • ConcurrentHashMap采用了Segment数组 + table + Entry
• • HashMap非线程安全，ConcurrentHashMap线程安全
• • HashMap在扩容时，存在环形链表问题
• • ConcurrentHashMap慎用size、containsValue，因为会锁住整个Segment
• 1.8
• • HashMap与ConcurrentHashMap都引入了红黑树，数据结构上都是数组+链表+红黑树
• • HashMap中由原来的Entry节点变成Node节点，TreeNode并不是继承于Node，而是中间继承了一次linkedHashMap中的Entry，而此Entry却是继承于HashMap中的Node节点
• • HashMap解决了循环链表问题，解决方式是将原头插法改成尾插法
• • ConcurrentHashMap引入红黑树后，在get方法时，通过根节点的TreeBin的hash值(小于0就是红黑树)来判断是红黑树还是链表
• • HashMap基本结构：数组+（TreeNode 或 Node）
• • ConcurrentHashMap基本数据结构：数组+（TreeBin（仅根节点） + TreeNode（其他节点都是TreeNode） 或 Node ）
• • 两者阈值固定0.75倍
• • 两者在1.7都是采用头插法，在1.8中都采用尾插法
• • ConcurrentHashMap1.7初始化时需要初始化数组第一个元素，而在1.8并不会进行初始化，只会将并发度转换成当前值最小的2的倍数
• • 两者的转换值都一样，由链表转化成红黑树为8，红黑树转换成链表为6

面试常见问题汇总
HashMap与HashTable的区别

• HashMap线程不安全，HashTable线程安全，由于HashTable线程安全，所以性能没有HashMap好
• HashMap初始容量为16，HashTable初始容量为11
• HashMap允许为null，HashTable不允许
• HashMap扩容需要重新计算hash，HashTable直接使用对象的hashCode

Java 与 中的另一个线程安全的与 HashMap 极其类似的类是什么？同样是与 线程安全，它与 HashTable 在线程同步上有什么不同？

• ConcurrentHashMap 类（是 Java 并发包 java.util.concurrent 中提供的一个线程安全且高效的 HashMap 实现）。

• HashTable 是使用 synchronize 关键字加锁的原理（就是对对象加锁）；

• 而针对 ConcurrentHashMap，在 JDK 1.7 中采用分段锁的方式；JDK 1.8 中直接采用了 CAS（无锁算法）+ synchronized，也采用分段锁的方式并大大缩小了锁的粒度。
  HashMap & ConcurrentHashMap 的区别？

• 除了加锁，原理上无太大区别。

• 另外，HashMap 的键值对允许有 null，但是 ConCurrentHashMap 都不允许。

• 在数据结构上，红黑树相关的节点类，HashMap的红黑树继承于linkedHashMap.Entry，而ConCurrentHashMap中红黑树继承于Node节点
  为什么 ConcurrentHashMap 比 HashTable 效率要高？

• HashTable 使用一把锁（锁住整个链表结构）处理并发问题，多个线程
  竞争一把锁，容易阻塞；

• ConcurrentHashMap JDK 1.7 中使用分段锁（ReentrantLock + Segment + HashEntry），相当于把一个 HashMap 分成多个段，每段分配一把锁，这样支持多线程访问。锁粒度：基于 Segment，包含多个 HashEntry。

• JDK 1.8 中使用 CAS + synchronized + Node + 红黑树。锁粒度：Node（首结点）（实现 Map.Entry<K,V>）。锁粒度降低了。
  针对 ConcurrentHashMap 锁机制具体分析（JDK 1.7 VS JDK 1.8 ）？

• JDK 1.7 中，采用分段锁的机制，实现并发的更新操作，底层采用数组+链表的存储结构，包括两个核心静态内部类 Segment 和 HashEntry。

• • ①、Segment 继承 ReentrantLock（重入锁） 用来充当锁的角色，每个
    Segment 对象守护每个散列映射表的若干个桶；
• • ②、HashEntry 用来封装映射表的键-值对；
• • ③、每个桶是由若干个 HashEntry 对象链接起来的链表。

• JDK 1.8 中，采用 Node + CAS + Synchronized 来保证并发安全。取消类Segment，直接用 table 数组存储键值对；当 HashEntry 对象组成的链表长度超过 TREEIFY_THRESHOLD 时，链表转换为红黑树，提升性能。底层变更为数组 +链表 + 红黑树。

ConcurrentHashMap 在JDK 1.8 中 ，锁为什么要使用内置锁synchronized锁 来代替重入锁 ReentrantLock ？

• 1、JVM 开发团队在 1.8 中对 synchronized 做了大量性能上的优化，而且基于 JVM 的 synchronized 优化空间更大，更加自然。
• 2、在大量的数据操作下，对于 JVM 的内存压力，基于 API ReentrantLock 会开销更多的内存。

ConcurrentHashMap 简单介绍？

• ①、重要的常量：
• • private transient volatile int sizeCtl;
• • 当为负数时，-1 表示正在初始化，-N 表示 N - 1 个线程正在进行扩容；
• • 当为 0 时，表示 table 还没有初始化；
• • 当为其他正数时，表示初始化或者下一次进行扩容的大小。
• ②、数据结构：
• • Node 是存储结构的基本单元，实现了Map接口中的 Entry，用于存储数据；
• • TreeNode 继承 Node，但是数据结构换成了二叉树结构，是红黑树的存储结构，用于红黑树中存储数据；
• • TreeBin 是封装 TreeNode 的容器，提供转换红黑树的一些条件和锁的控制。
• ③、存储对象时（put() 方法）：
• • 1.如果没有初始化，就调用 initTable() 方法来进行初始化；
• • 2.如果没有 hash 冲突就直接 CAS 无锁插入；
• • 3.如果需要扩容，就先进行扩容；
• • 4.如果存在 hash 冲突，就加锁来保证线程安全，两种情况：一种是链表形式就直接遍历到尾端插入，一种是红黑树就按照红黑树结构插入；
• • 5.如果该链表的数量大于阀值 8，就要先转换成红黑树的结构，break 再一次进入循环
• • 6.如果添加成功就调用 addCount() 方法统计 size，并且检查是否需要扩容。
• ④、扩容方法 transfer()：默认容量为 16，扩容时，容量变为原来的两倍。helpTransfer()：调用多个工作线程一起帮助进行扩容，这样的效率就会更高。
• ⑤、获取对象时（get()方法）：
• • 1.计算 hash 值，定位到该 table 索引位置，如果是首结点符合就返回；
• • 2.如果遇到扩容时，会调用标记正在扩容结点 ForwardingNode.find()方法，查找该结点，匹配就返回；
• • 3.以上都不符合的话，就往下遍历结点，匹配就返回，否则最后就返回null。
    ConcurrentHashMap 的并发度是什么？
• 1.7 中程序运行时能够同时更新 ConccurentHashMap 且不产生锁竞争的最大线程数。默认为 16，且可以在构造函数中设置。当用户设置并发度时，ConcurrentHashMap 会使用大于等于该值的最小 2 幂指数作为实际并发度（假如用户设置并发度为 17，实际并发度则为 32）。
• 1.8 中并发度则无太大的实际意义了，主要用处就是当设置的初始容量小于并发度，将初始容量提升至并发度大小。