第四章 并发容器ConcurrentHashMap笔记

HashMap多线程会导致HashMap的Entry链表形成环形数据结构，一旦形成环形数据结构，Entry的next节点永远不为空，就会产生死循环获取Entry。

HashTable使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法，其他线程也访问HashTable的同步方法时，会进入阻塞或轮询状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。

putIfAbsent() ：没有这个值则放入map，有这个值则返回key本来对应的值。

一、预备知识

1、Hash算法：

散列，哈希：把任意长度的输入通过一种算法（散列），变换成为固定长度的输出，这个输出值就是散列值。属于压缩映射，容易产生哈希冲突。Hash算法有直接取余法等。

产生哈希冲突时解决办法：

• 开放寻址
• 再散列
• 链地址法（相同hash值的元素用链表串起来）

ConcurrentHashMap在发生hash冲突时采用了链地址法。md4,md5,sha-hash算法也属于hash算法，又称摘要算法。
常用hash算法的介绍：
（1) MD4 （2) MD5它对输入仍以512位分组，其输出是4个32位字的级联（3) SHA-1及其他。

2、位运算：

int类型的位

2的0次方 = 1，2的1次方=2…….，以上表格代表数字 （2的5次方+2的3次方）= 40
由上面的表格可以看出，数字类型在数字渐渐变大时，是由低位慢慢向高位扩展的。
Java实际保存int型时 正数 第31位 =0 负数：第31位=1

常用位运算有：

• 位与 & (1&1=1 1&0=0 0&0=0)
• 位或 | (1|1=1 1|0=1 0|0=0)
• 位非 ~（ ~1=0 ~0=1）
• 位异或 ^ (1^1=0 1^0=1 0^0=0)
• <<有符号左移 >>有符号的右移 >>>无符号右移 例如：8 << 2 = 32 8>>2 = 2

取模的操作 a % (Math.pow(2,n)) 等价于 a&( Math.pow(2,n)-1)

有趣的取模性质：取模a % (2^n) 等价于 a & (2^n - 1)，所以在map里的数组个数一定是2的乘方数，计算key值在哪个元素中的时候，就用位运算来快速定位。

3、位运算运用场景

Java中的类修饰符、成员变量修饰符、方法修饰符，比如Class类中
Java容器中的HashMap和ConcurrentHashMap的实现
权限控制或者商品属性
简单可逆加密，比如异或运算(1^1=0 ; 0^1=1 )
实战：权限控制，com.chj.thread.capt05.bitconvert.Permission
使用位运算的优劣势：
节省很多代码量、效率高、属性变动影响小、不直观

二、线程不安全的HashMap

HashMap 里面是一个数组，然后数组中每个元素是一个单向链表，因为多线程环境下，使用Hashmap进行put操作会引起死循环，导致CPU利用率接近100%，所以在并发情况下不能使用HashMap。
Java1.7的HashMap结构：

上图中，每个绿色的实体是嵌套类 Entry 的实例，Entry 包含四个属性：key, value, hash 值和用于单向链表的 next。

• capacity：当前数组容量，始终保持 2^n，可以扩容，扩容后数组大小为当前的 2 倍。
• loadFactor：负载因子，默认为 0.75。
• threshold：扩容的阈值，等于 capacity * loadFactor

1.术语定义

哈希算法hash algorithm：
是一种将任意内容的输入转换成相同长度输出的加密方式，其输出被称为哈希值。
哈希表hash table:
根据设定的哈希函数H(key)和处理冲突方法将一组关键字映象到一个有限的地址区间上，并以关键字在地址区间中的象作为记录在表中的存储位置，这种表称为哈希表或散列，所得存储位置称为哈希地址或散列地址。

2.put过程分析:

2.1源码分析：

public V put(K key, V value) {
    // 当插入第一个元素的时候，需要先初始化数组大小
    if (table == EMPTY_TABLE) {
        inflateTable(threshold); //capacity * loadFactor
    }
    // 如果 key 为 null，感兴趣的可以往里看，最终会将这个 entry 放到 table[0] 中
    if (key == null)
        return putForNullKey(value);
    // 1. 求 key 的 hash 值
    int hash = hash(key);
    // 2. 找到对应的数组下标
    int i = indexFor(hash, table.length);
    // 3. 遍历一下对应下标处的链表，看是否有重复的 key 已经存在，
    //    如果有，直接覆盖，put 方法返回旧值就结束了
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    // 4. 不存在重复的 key，将此 entry 添加到链表中，细节后面说
    addEntry(hash, key, value, i);
    return null;
}

2.2 数组初始化:

在第一个元素插入 HashMap 的时候做一次数组的初始化，就是先确定初始的数组大小，并计算数组扩容的阈值

private void inflateTable(int toSize) {
    // 保证数组大小一定是 2 的 n 次方。
    // 比如这样初始化：new HashMap(20)，那么处理成初始数组大小是 32
    int capacity = roundUpToPowerOf2(toSize);
    // 计算扩容阈值：capacity * loadFactor
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    // 算是初始化数组吧
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity); //ignore
}

2.3 添加节点到链表中:

找到数组下标后，会先进行 key 判重，如果没有重复，就准备将新值放入到链表的表头。

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 如果当前 HashMap 大小已经达到了阈值，并且新值要插入的数组位置已经有元素了，那么要扩容
    if ((size >= threshold) && (null != table[bucketIndex])) {
        // 扩容，后面会介绍一下
        resize(2 * table.length);
        // 扩容以后，重新计算 hash 值
        hash = (null != key) ? hash(key) : 0;
        // 重新计算扩容后的新的下标
        bucketIndex = indexFor(hash, table.length);
    }
    // 往下看
    createEntry(hash, key, value, bucketIndex);
}
// 这个很简单，其实就是将新值放到链表的表头，然后 size++
void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

3.get 过程分析

相对于 put 过程，get 过程是非常简单的。
1)根据 key 计算 hash 值。
2)找到相应的数组下标：hash & (length – 1)。
3)遍历该数组位置处的链表，直到找到相等(==或equals)的 key。

public V get(Object key) {
    // 之前说过，key 为 null 的话，会被放到 table[0]，所以只要遍历下 table[0] 处的链表就可以了
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);
    return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
    if (size == 0) { return null;}
    int hash = (key == null) ? 0 : hash(key);
    // 确定数组下标，然后从头开始遍历链表，直到找到为止
    for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    	 }
    	return null;
}

4.效率低下的HashTable容器

HashTable容器使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法时，其他线程访问HashTable的同步方法时，可能会进入阻塞或轮询状态。如线程1使用put进行添加元素，线程2不但不能使用p