HashMap和ConcurrentHashMap

---

一、 什么是HashMap？

和Set，ArrayList等集合不一样，HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Entry。这些个键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。

举个例子：
例如一个学生包括（学号，姓名，年龄，身高，体重，电话 … 等等信息）

我们就可以根据这个学生的学号（key）找到这个学生的其他信息（Value）

二、HashMap数据结构

JDK1.7及之前使用 数组 + 链表 存储数据

JDK1.8之后使用 数组 + 链表/红黑树 存储数据

注：只有当数组长度大于64，并且链表长度大于8（证明hash冲突很严重，链表长度过长，严重降低了查询效率），会转换成树形结构红黑树（red black tree）

那么这里设置链表长度是8，转换成红黑树，为什么不是7或9呢？

因为在理想情况下，在随机 hashCodes 下， Node节点服从泊松分布,而发生单个链表的长度大于8的概率为0.00000006，可以说是基本不可能发生。

那么为什么不能就用链表，非要多加一个红黑树呢？

因为HashMap中桶（一个数组下标对应的链表/红黑树也就是桶）的元素初始化是链表保存的，其查找效率为O(n)，而树结构能将查找效率提升到O(log(n))。当链表长度很小的时候，即使遍历，速度也非常快，但是当链表长度不断变长，肯定会对查询性能有一定的影响，所以才需要转成树。

三、HashMap的put方法（插入原理）

第一步 ：先判断数组是否为空，如果为空则初始化。

这里默认的initialCapacity（初始容量）为16，DEFAULT_LOAD_FACTOR（负载因子）为0.75

如果使用的构造方法传入的值为12那么初始化容量就为16(2^4)；
如果传入的值为20那么初始化容量就为32（2^5）；
也就是说通过tableSizeFor方法无论传入的cap值是多少，最后初使容量都会是大于cap值的最小2的幂指数

// initialCapacity —— 初始容量  1<<4 = 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;  
//DEFAULT_LOAD_FACTOR —— 负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f; 
public HashMap(int initialCapacity) {
   this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

// 
static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

第二步：如果数组不为空，计算 key 的 hash 值，数组的下标index通过(n - 1) & hash计算得出（n = tab.length 也是数组的长度）

返回的(h = key.hashCode()) ^ (h >>> 16) 意思是hashCode有32位，前16位和后16位及进行异或，尽可能减少碰撞。

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

那么计算hash的hashCode值怎么获取的呢？

Object类有hashCode()方法，返回的是对象的hashcode值，具体存放在对象的markword里（也就是对象头里）。

// Object类的hashCode()方法
public native int hashCode();

// 这里用Integer类的hashCode()举例，返回的hashcode值就是value值
 public static int hashCode(int value) {
        return value;
    }
    
// String类的hashCode()
public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

注意：如果是自定义的类，必须要重写equals()方法和hashcode()方法，否则进行使用put方法会出现问题。

​第三步：查看 table[index] 是否存在数据，没有数据就构造一个Node节点存放在 table[index] 中；

​第四步：存在数据，说明发生了hash冲突(存在二个节点key的hash值一样), 使用equals方法和hashcode值比较，如果都相等，那么说明key值一样，此时后添加的value会覆盖之前存储的value

​第五步：若不相等，判断当前节点类型是不是树型节点，如果是树型节点，创造树型节点插入红黑树中；

​第六步：若不是红黑树，创建普通Node加入链表中；判断链表长度是否大于 8，大于则将链表转换为红黑树；

​第七步：插入完成之后判断当前节点数是否大于阈值，若大于，则扩容为原数组的二倍。扩容是指重新创建一个原数组二倍容量的新数组，然后将旧数组里的数组重新插入到新数组里（这里是先插入，再扩容）

// 阈值计算
threshold = loadFactor * initialCapacity  
如果Map.size() > threshold 就会触发hashmap的扩容机制
注意：Map.size()指的不是数组的长度，而是map里拥有Node的数量

四、HashMap线程是否安全

答案是HashMap线程是不安全的，因为在并发环境下（多线程对共享资源进行访问修改时），使用HashMap进行put操作，会出现死循环和数据覆盖的情况，死循环会导致CPU的使用率达到100%，因此在并发环境下不要使用HashMap。

那么高并发的环境下怎么办呢？
解决方法：
1.加锁
而单纯的在put方法加synchronized重量级锁（一个一个来，第一个线程获取了对象锁，其他的线程在等待队列里等待第一个对象释放锁，才能获取对象锁），但是这样相当于串行化，虽然保证了并发情况下的安全问题，而执行效率会大大降低。

2.使用ConcurrentHashMap
原理：加分段锁，避免了全局加锁改成了局部加锁，极大地提高了并发环境的操作效率。
ConcurrentHashMap结构：

JDK1.8之前
使用的是segment（分段锁,段的默认长度为16）+ 数组 + 链表,

segment继承reentrantlock，在并发情况下，访问其中一个segment并不影响其他线程访问其他的segment。解决了并发情况下的安全问题，效率也比单纯加synchronized执行效率要高很多。但是数据访问效率会有所下降，因为正常的hashmap访问数据直接定位到数据下标，而ConcurrentHashMap会先定位到对应segment在定位到具体下标，相当于多了一次访问。

JDK1.8之后
使用的是node + 数组 + 链表/红黑树，也就是锁的粒度变小了（从锁16个桶变成锁1个桶），效率提高很多。

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;
 }

Node中存储的val和next都使用了volatile进行修饰，保证了多线程之间的数据可见性。
内部锁使用CAS（compare and swap，即比较交换）实现的。java中锁分为乐观锁和悲观锁。悲观锁是将共享资源加锁之后，其他线程无法进行访问修改，必须等待所释放之后，才可以访问。而乐观锁认为数据一般情况下不会造成冲突,通过某种方式不加锁处理数据所以在数据进行提交更新的时候,才会正式对数据的冲突与否进行检测。CAS是乐观锁，CAS 操作包含三个操作数 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，如果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。

但是CAS也存在问题
1.如果很多线程不断自旋，会给CPU带来很大的压力
2.ABA问题
举个例子：
现在有三个线程1,2,3 和一个共享资源 A
线程1和线程2获取了A的值
线程1先一步提交 将A 值—> B值
线程2因为某些原因挂起了
线程3获取B值，将B值 —> A值
此时线程2恢复运行状态，因为共享资源是A值经过Compare之后没啥问题就将A值 —> B值

ABA解决方法:加版本号（version）