From 08cde78045108767ff0f234c2c8f36112550934e Mon Sep 17 00:00:00 2001 From: Dragon <1826692270@qq.com> Date: Sun, 1 Nov 2020 10:45:31 +0800 Subject: [PATCH] HashMap --- README.md | 12 +- .../keyAndDifficultPoints/Generic/泛型.md | 4 +- docs/Java/collection/HashMap-JDK7源码讲解.md | 1134 +++++++++++++++++ .../HashMap-JDK8源码讲解及常见面试题.md | 694 ++++++++++ .../Java并发体系-第四阶段-AQS源码解读-[1].md | 2 +- 5 files changed, 1840 insertions(+), 6 deletions(-) create mode 100644 docs/Java/collection/HashMap-JDK7源码讲解.md create mode 100644 docs/Java/collection/HashMap-JDK8源码讲解及常见面试题.md diff --git a/README.md b/README.md index b2338ca..6d49719 100644 --- a/README.md +++ b/README.md @@ -51,9 +51,15 @@ ## 容器 -1、HashMap源码讲解（JDK7和JDK8）【TODO】 +**HashMap** -2、ConcurrentHashMap源码讲解（JDK7和JDK8）【TODO】 +[HashMap-JDK7源码讲解](docs/Java/collection/HashMap-JDK7源码讲解.md) + +[HashMap-JDK8源码讲解及常见面试题](docs/Java/collection/HashMap-JDK8源码讲解及常见面试题.md) + + + +**ConcurrentHashMap源码讲解（JDK7和JDK8）【TODO】** @@ -77,7 +83,7 @@ -AQS，阻塞队列源码还在准备中。预计12月前可以写的差不多 +AQS剩余部门，阻塞队列源码还在准备中。预计12月前可以写的差不多 diff --git a/docs/Java/Basis/keyAndDifficultPoints/Generic/泛型.md b/docs/Java/Basis/keyAndDifficultPoints/Generic/泛型.md index f92858d..5de3736 100644 --- a/docs/Java/Basis/keyAndDifficultPoints/Generic/泛型.md +++ b/docs/Java/Basis/keyAndDifficultPoints/Generic/泛型.md @@ -5,8 +5,8 @@ tags: - 基础 - 泛型 categories: - - Java - - 新特性 + - Java基础 + - 重难点 keywords: Java基础，泛型 description: 万字长文详解Java泛型。 cover: 'https://cdn.jsdelivr.net/gh/youthlql/lql_img/Java_Basis/logo.png' diff --git a/docs/Java/collection/HashMap-JDK7源码讲解.md b/docs/Java/collection/HashMap-JDK7源码讲解.md new file mode 100644 index 0000000..e0478e5 --- /dev/null +++ b/docs/Java/collection/HashMap-JDK7源码讲解.md @@ -0,0 +1,1134 @@ +--- +title: HashMap-JDK7源码讲解 +tags: + - Java集合 + - HashMap +categories: + - Java集合 + - HashMap +keywords: Java集合，HashMap。 +description: HashMap-JDK7源码讲解。 +cover: 'https://cdn.jsdelivr.net/gh/youthlql/lql_img/Java_Basis/logo.png' +top_img: 'https://cdn.jsdelivr.net/gh/youthlql/lql_img/blog/top_img.jpg' +date: 2020-11-1 10:21:58 +--- + + + + + +> 本文基于版本 `JDK 1.7`，即 `Java 7`。 + +# HashMap用法 + +## 常用API + +```java +V get(Object key); // 获得指定键的值 +V put(K key, V value); // 添加键值对 +void putAll(Map m); // 将指定Map中的键值对 复制到 此Map中 +V remove(Object key); // 删除该键值对 + +boolean containsKey(Object key); // 判断是否存在该键的键值对；是 则返回true +boolean containsValue(Object value); // 判断是否存在该值的键值对；是 则返回true + +Set keySet(); // 单独抽取key序列，将所有key生成一个Set +Collection values(); // 单独value序列，将所有value生成一个Collection + +void clear(); // 清除哈希表中的所有键值对 +int size(); // 返回哈希表中所有 键值对的数量 = 数组中的键值对 + 链表中的键值对 +boolean isEmpty(); // 判断HashMap是否为空；size == 0时 表示为 空 +``` + + + +```java + +import java.util.*; +import java.util.concurrent.*; + + +/** + * @Author: youthlql-吕 + * @Date: 2020/10/11 21:05 + *

+ * 功能描述: + */ +public class test { + //声明1个 HashMap的对象 + static Map map = new HashMap<>(); + + public static void main(String[] args) { + + //向HashMap添加数据（成对 放入 键 - 值对） + map.put("Java", 1); + map.put("hadoop", 2); + map.put("产品经理", 3); + + //获取 HashMap 的某个数据 + System.out.println("key = 产品经理时的值为：" + map.get("产品经理")); + + System.out.println(); + System.out.println("------------------下面是遍历-------------------"); + test(); + + } + + + /** + * 获取HashMap的全部数据：遍历HashMap + */ + public static void test(){ + + + // 方法1：获得key-value的Set集合 再遍历 + System.out.println("------------方法1------------"); + // 1、获得key-value对（Entry）的Set集合 + Set> entrySet = map.entrySet(); + + // 2、遍历Set集合，从而获取key-value + for (Map.Entry entry : entrySet) { + System.out.print(entry.getKey()); + System.out.println(entry.getValue()); + } + System.out.println("----------"); + // 2.1、通过迭代器：先获得key-value对（Entry）的Iterator，再循环遍历 + Iterator iter1 = entrySet.iterator(); + while (iter1.hasNext()) { + // 遍历时，需先获取entry，再分别获取key、value + Map.Entry entry = (Map.Entry) iter1.next(); + System.out.print((String) entry.getKey()); + System.out.println((Integer) entry.getValue()); + } + + + + + // 方法2：获得key的Set集合 再遍历 + System.out.println("------------方法2------------"); + + // 1. 获得key的Set集合 + Set keySet = map.keySet(); + + // 2. 遍历Set集合，从而获取key，再获取value + // 2.1 通过for循环 + for (String key : keySet) { + System.out.print(key); + System.out.println(map.get(key)); + } + + System.out.println("----------"); + + // 2.2 通过迭代器：先获得key的Iterator，再循环遍历 + Iterator iter2 = keySet.iterator(); + String key = null; + while (iter2.hasNext()) { + key = (String) iter2.next(); + System.out.print(key); + System.out.println(map.get(key)); + } + + + + // 方法3：获得value的Set集合 再遍历 + System.out.println("------------方法3------------"); + + // 1. 获得value的Set集合 + Collection valueSet = map.values(); + + // 2. 遍历Set集合，从而获取value + // 2.1 获得values 的Iterator + Iterator iter3 = valueSet.iterator(); + // 2.2 通过遍历，直接获取value + while (iter3.hasNext()) { + System.out.println(iter3.next()); + } + } + + +} +/** + * 对于遍历方式，推荐使用针对 key-value对（Entry）的方式：效率高 + * 原因： + * 1. 对于 遍历keySet 、valueSet，实质上 = 遍历了2次： + * 第一次转为iterator迭代器遍历、 + * 第二次从HashMap中取出key和value操作 + * 2. 对于遍历entrySet，实质只遍历了1次，也就是获取存储实体Entry（存储了key 和 value ） + */ + +``` + + + +**结果** + +``` +key = 产品经理时的值为：3 + +------------------下面是遍历------------------- +------------方法1------------ +Java1 +hadoop2 +产品经理3 +---------- +Java1 +hadoop2 +产品经理3 +------------方法2------------ +Java1 +hadoop2 +产品经理3 +---------- +Java1 +hadoop2 +产品经理3 +------------方法3------------ +1 +2 +3 +``` + + + + + +# 数据结构 + +## 简介 + +1、HashMap是散列表的一种，HashMap本身采用数组来进行储存。同时HashMap采用拉链法来解决hash冲突，拉链法就是通过链表来解决hash冲突。所以说整体上来看，HashMap采用的数据结构 = **数组（主） + 单链表（副）** + + + +大致是这样的一个结构 + + + +- 每个链表就算哈希表的桶（bucket） +- 链表的节点值就算一个键值对 + +## 重要参数介绍 + +**构造函数源码** + +先贴一下，后面参数介绍会使用到。 + +```java + public HashMap(int initialCapacity, float loadFactor) { + if (initialCapacity < 0) + throw new IllegalArgumentException("Illegal initial capacity: " + + initialCapacity); + if (initialCapacity > MAXIMUM_CAPACITY) + initialCapacity = MAXIMUM_CAPACITY; + if (loadFactor <= 0 || Float.isNaN(loadFactor)) + throw new IllegalArgumentException("Illegal load factor: " + + loadFactor); + + this.loadFactor = loadFactor; + threshold = initialCapacity; + init(); + } + + + public HashMap(int initialCapacity) { + this(initialCapacity, DEFAULT_LOAD_FACTOR); + } + + public HashMap() { + this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); + } + + + public HashMap(Map m) { + this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, + DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR); + inflateTable(threshold); + + putAllForCreate(m); + } +``` + + + +> 下面的代码有些顺序和源码可能不太一样，仅仅是顺序，笔者是为了更好的阅读体验 + +```java +public class HashMap + extends AbstractMap + implements Map, Cloneable, Serializable +{ + + /* + 名词介绍： + 1、容量（capacity）： HashMap中数组【强调一下是数组，不是元素个数】的长度 + 2、容量范围：必须是2的幂并且小于最大容量（2的30次方） + 3、初始容量 = 哈希表创建时的容量 + */ + + //默认初始容量 = 哈希表创建时的容量。默认容量 = 16 = 1<<4 = 00001中的1向左移4位 = 十进制的2^4=16 + static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 + + // 最大容量 = 2的30次方（若传入的容量过大，将被最大值替换） + static final int MAXIMUM_CAPACITY = 1 << 30; + + /* + 1、加载因子(Load factor)：HashMap在其容量自动增加前的一种尺度。 + 2、加载因子越大、填满的元素越多 = 空间利用率高、但hash冲突的机会加大、查找效率变低（因为链表变长了） + 3、加载因子越小、填满的元素越少 = 空间利用率小、hash冲突的机会减小、查找效率高（链表不长） + */ + + // 实际加载因子 + final float loadFactor; + + // 默认加载因子 = 0.75 + static final float DEFAULT_LOAD_FACTOR = 0.75f; + + //就是上面说的数组，hashmap用Entry数组储存k-v键值对 + transient Entry[] table = (Entry[]) EMPTY_TABLE; + + static final Entry[] EMPTY_TABLE = {}; + + + // HashMap的大小，即HashMap中存储的键值对的数量。注意：和容量区分开，容量是数组Entry的长度 + transient int size; + + + /* + 1、扩容阈值（threshold）：当哈希表的大小【就是上面的size】 ≥ 扩容阈值时，就会扩容哈希表（即扩充HashMap的 容量） + 2、扩容 = 对哈希表进行resize操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数 + 3、扩容阈值 = 容量 x 加载因子 + */ + int threshold; + + +``` + + + + + +## 数组-Entry + +```java +/** + * Entry类实现了Map.Entry接口 + * 即 实现了getKey()、getValue()、equals(Object o)和hashCode()等方法 +**/ +static class Entry implements Map.Entry { + final K key; // 键 + V value; // 值 + Entry next; // 指向下一个节点 ，也是一个Entry对象，从而形成解决hash冲突的单链表 + int hash; // hash值 + + /** + * 构造方法，创建一个Entry + * 参数：哈希值h，键值k，值v、下一个节点n + */ + Entry(int h, K k, V v, Entry n) { + value = v; + next = n; + key = k; + hash = h; + } + + // 返回 与 此项 对应的键 + public final K getKey() { + return key; + } + + // 返回 与 此项 对应的值 + public final V getValue() { + return value; + } + + public final V setValue(V newValue) { + V oldValue = value; + value = newValue; + return oldValue; + } + + /** + * equals（） + * 作用：判断2个Entry是否相等，必须key和value都相等，才返回true + */ + public final boolean equals(Object o) { + if (!(o instanceof Map.Entry)) + return false; + Map.Entry e = (Map.Entry)o; + Object k1 = getKey(); + Object k2 = e.getKey(); + if (k1 == k2 || (k1 != null && k1.equals(k2))) { + Object v1 = getValue(); + Object v2 = e.getValue(); + if (v1 == v2 || (v1 != null && v1.equals(v2))) + return true; + } + return false; + } + + /** + * hashCode（） + */ + public final int hashCode() { + return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue()); + } + + public final String toString() { + return getKey() + "=" + getValue(); + } + + /** + * 当向HashMap中添加元素时，即调用put(k,v)时， + * 对已经在HashMap中k位置进行v的覆盖时，会调用此方法 + * 此处没做任何处理 + */ + void recordAccess(HashMap m) { + } + + /** + * 当从HashMap中删除了一个Entry时，会调用该函数 + * 此处没做任何处理 + */ + void recordRemoval(HashMap m) { + } + +} +``` + +`HashMap`中的数组元素 & 链表节点 采用 `Entry`类实现 + + + +1、一个正方形代表一个Entry对象，同时也代表一个键值对。 + +2、即 `HashMap`的本质 = 1个存储`Entry`类对象的数组 + 多个单链表 + +3、Entry对象本质 = 1个映射（键 - 值对），属性包括：键（`key`）、值（`value`）、 下个节点( `next`) = 单链表的指针 = 也是一个`Entry`对象，用于解决`hash`冲突 + + + + + +# 构造函数源码 + +```java + + public class HashMap + extends AbstractMap + implements Map, Cloneable, Serializable{ + + // 省略上节阐述的参数 + + /* + 构造函数1：默认构造函数（无参） + 加载因子和容量为默认，分别是0.75和16 + */ + public HashMap() { + /* + 实际上是调用构造函数3：指定"容量大小"和"加载因子"的构造函数 + 传入的指定容量和加载因子均为默认 + */ + this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); + } + + /* + 构造函数2：指定"容量大小"的构造函数 + 加载因子是默认的0.75 、容量为指定大小 + */ + public HashMap(int initialCapacity) { + // 实际上是调用的也是构造函数3，只是在传入的加载因子参数为默认加载因子 + this(initialCapacity, DEFAULT_LOAD_FACTOR); + + } + + /* + 构造函数3：指定“容量大小”和“加载因子”的构造函数 + 加载因子和容量都是程序员自己指定 + */ + public HashMap(int initialCapacity, float loadFactor) { + + // HashMap的最大容量只能是MAXIMUM_CAPACITY，哪怕传入的 > 最大容量 + if (initialCapacity > MAXIMUM_CAPACITY) + initialCapacity = MAXIMUM_CAPACITY; + + // 设置加载因子 + this.loadFactor = loadFactor; + + /* + 设置扩容阈值 = 初始容量 + 1、注意：此处不是真正的阈值，仅是为了接收参数初始容量大小（capacity）、加载因子(Load factor)，并没 有真正初始化哈希表，即初始化存储数组table + 2、真正初始化哈希表（初始化存储数组table）是在第1次添加键值对时，即第1次调用put()时，下面会详细说明。 + */ + threshold = initialCapacity; + + init(); // 一个空方法用于未来的子对象扩展 + } + + /* + 构造函数4：包含“子Map”的构造函数 + 即构造出来的HashMap包含传入Map参数 + 加载因子和容量均为默认 + */ + public HashMap(Map m) { + + // 设置容量大小和加载因子为默认值 + this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, + DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR); + + // 该方法用于初始化数组和阈值 + inflateTable(threshold); + + // 将传入的子Map中的全部元素逐个添加到HashMap中 + putAllForCreate(m); + } +} + +``` + + + +# put()源码 + +## put() + +```java +public V put(K key, V value) { + + /* ① + 1、若哈希表未初始化（即 table为空)，则调用inflateTable方法，使用构造函数时设置的阈值(即初始容量)初 始化数组table + */ + if (table == EMPTY_TABLE) { + inflateTable(threshold); + } + /* ② + 1、判断key是否为空值null + 2、若key == null，则调用putForNullKey方法，putForNullKey方法最终将该键-值存放到数组table中的第1 个位置，即table[0]。本质：key = Null时，hash值 = 0，故存放到table[0]中）该位置永远只有1个value， 新传进来的value会覆盖旧的value + 3、k != null往下走 + */ + if (key == null) + return putForNullKey(value); + //下面就是k != null的情况 + + //计算key的hash值 + int hash = hash(key); + //根据hash值最终获得key对应存放的数组Table中位置(也就是数组下标) + int i = indexFor(hash, table.length); + + /* ③ + 1、通过遍历以该数组元素为头结点的链表，逐个判断是否发生hash冲突，同时判断该key对应的值是否已存在 + */ + for (Entry e = table[i]; e != null; e = e.next) { + Object k; + /* ④ + 1、如果发生了hash冲突，且key也相等。则用新value替换旧value(此时说明发生了更新的情况)，注意这里 强调的是发生了hash冲突并且key也相等。 + */ + if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { + V oldValue = e.value; + e.value = value; + e.recordAccess(this); + return oldValue; + } + } + //修改次数+1 + modCount++; + /* ⑤ + 1、走到这一步有两种情况 + 1-1、没有发生hash冲突 + 1-2、发生了hash冲突，但是没有在链表中找到key一样的键 + 2、接着准备采用头插法，插入链表的头部(也就是数组里面) + */ + addEntry(hash, key, value, i); + return null; + } +``` + + + +## inflateTable() + +```java + +private void inflateTable(int toSize) { + /* + 将传入的容量大小转化为：>传入容量大小的最小的2的次幂，即如果传入的是容量大小是18，那么转化后，初始化容量 大小为32（即2的5次幂） + */ + int capacity = roundUpToPowerOf2(toSize); + + //重新计算阈值 threshold = 容量 * 加载因子 + threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); + /* + 使用计算后的初始容量（已经是2的次幂） 初始化数组table（作为数组长度）即 哈希表的容量大小 = 数组大小（长 度） + */ + table = new Entry[capacity]; + initHashSeedAsNeeded(capacity); +} +``` + + + +### roundUpToPowerOf2() + +```java +private static int roundUpToPowerOf2(int number) { + //若容量超过了最大值，初始化容量设置为最大值 ；否则，设置为>传入容量大小的最小的2的次幂 + return number >= MAXIMUM_CAPACITY + ? MAXIMUM_CAPACITY + : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1; +} +``` + + + +## putForNullKey() + +当 key ==null时，将该 key-value 的存储位置规定为数组table 中的第1个位置，即table [0] + +```java +private V putForNullKey(V value) { + + /* + 1、遍历以table[0]为首的链表，寻找是否存在key==null对应的键值对 + 1-1、若有：则用新value替换旧value；同时返回旧的value值。 + */ + for (Entry e = table[0]; e != null; e = e.next) { + if (e.key == null) { + V oldValue = e.value; + e.value = value; + e.recordAccess(this); + return oldValue; + } + } + modCount++; + + /* + 1、若无key==null的键，那么调用addEntry（），将空键和对应的值封装到Entry中，并放到table[0]中 + 2、能走到这里的情况就是table[0]位置之前没有元素，这一次是第一次添加key为null的元素 + 3、k == null已经是固定放在了table[0]的位置，不会有链表存在，只会有一个元素。 + */ + addEntry(0, null, value, 0); + return null; +} +``` + +从此处可以看出： + +* `HashMap`的键`key` 可为`null`（区别于 `HashTable`的`key` 不可为`null`） +* `HashMap`的键`key` 可为`null`且只能为1个，但值`value`可为null且为多个 + + + +## hash() + +> 这个方法比较重要，1.7和1.8改动的比较大 + +```java + /** + * 1、该函数在JDK7和8中的实现不同，但原理一样 = 扰动函数 = 使得根据key生成的 + * 哈希码（hash值）分布更加均匀、更具备随机性，避免出现hash值冲突（即指不同key但生成同1个hash值） + * 2、JDK 1.7 做了9次扰动处理 = 4次位运算 + 5次异或运算 + * 3、JDK 1.8 简化了扰动函数 = 只做了2次扰动 = 1次位运算 + 1次异或运算 + */ + final int hash(Object k) { + int h = hashSeed; + if (0 != h && k instanceof String) { + return sun.misc.Hashing.stringHash32((String) k); + } + + h ^= k.hashCode(); + //4次位运算 + 5次异或运算 + h ^= (h >>> 20) ^ (h >>> 12); + return h ^ (h >>> 7) ^ (h >>> 4); + } +``` + + + +## indexFor() + +```java +//这里h & (length-1)的意思就是hash值与数组长度取模。只是因为数组长度是特殊的2的幂，所以这个等价关系刚好成立 + static int indexFor(int h, int length) { + // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2"; + return h & (length-1); + } +``` + + + +## addEntry() + +```java + //作用：添加键值对（Entry）到HashMap中。参数3:插入数组table的索引位置,也就是数组下标 + //注意：JDK7是先扩容再插入 + void addEntry(int hash, K key, V value, int bucketIndex) { + /* + 1、插入前，先判断容量是否足够 + 1.1、若不足够，则进行扩容（2倍）、重新计算Hash值、重新计算存储数组下标 + */ + if ((size >= threshold) && (null != table[bucketIndex])) { + resize(2 * table.length); + hash = (null != key) ? hash(key) : 0; + bucketIndex = indexFor(hash, table.length); + } + // 1.2、若容量足够，则创建1个新的数组元素（Entry） 并放入到数组中 + createEntry(hash, key, value, bucketIndex); + } +``` + + + +# 扩容源码 + +下面的也是JDK7扩容的步骤，接着上面的`addEntry()` + +## resize() + +```java + /** + * 作用：当大小不足时（size > 阈值，注意是size，不是容量），则扩容（扩到2倍） + */ + void resize(int newCapacity) { + + // 1、保存旧数组（old table） + Entry[] oldTable = table; + + // 2、保存旧容量（old capacity ），即数组长度 + int oldCapacity = oldTable.length; + + // 3、若旧容量已经是系统默认最大容量了，那么将阈值设置成整型的最大值，返回 + if (oldCapacity == MAXIMUM_CAPACITY) { + threshold = Integer.MAX_VALUE; + return; + } + + // 4、根据新容量（2倍容量）新建1个数组，即newTable + Entry[] newTable = new Entry[newCapacity]; + + //5、将旧数组上的数据（键值对）转移到新table中，从而完成扩容 + transfer(newTable, initHashSeedAsNeeded(newCapacity)); + + // 6、新数组table引用到HashMap的table属性上 + table = newTable; + + // 7、重新设置阈值 + threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); +} + +``` + + + + + +## transfer() + + + +```java + /** + * 作用：将旧数组上的数据（键值对）转移到新table中，从而完成扩容 + * 过程：按旧链表的正序遍历链表、在新链表的头部依次插入。但是这样会导致扩容完成后，链表逆序 + */ +void transfer(Entry[] newTable, boolean rehash) { + int newCapacity = newTable.length; + //通过遍历 旧数组，将旧数组上的数据（键值对）转移到新数组中 + for (Entry e : table) { + while(null != e) { + /* + 1、遍历以该数组元素为首的链表 + 2、转移链表时，因是单链表，故要保存下1个结点，否则转移后链表会断开 + */ + Entry next = e.next; + if (rehash) { + e.hash = null == e.key ? 0 : hash(e.key); + } + //重新计算每个元素的存储位置 + int i = indexFor(e.hash, newCapacity); + + //这个地方暂时先放着，后面讲死循环链表的时候会讲到 + e.next = newTable[i]; + //讲当前元素，赋给新数组的对应下标位置。 + newTable[i] = e; + // 访问下1个Entry链上的元素，如此不断循环，直到遍历完该链表上的所有节点 + e = next; + } + } + } +``` + +大概画了一下图： + + + + + + + + + + + + + +1、在扩容`resize（）`过程中，在将旧数组上的数据转移到新数组上时，转移操作就是按旧链表的正序遍历链表、在新链表的头部依次插入，即在转移数据、扩容后，容易出现链表逆序的情况。 + +2、设重新计算存储位置后不变，即扩容前 1->2->3，扩容后 = 3->2->1 + +3、此时若（多线程）并发执行 put（）操作，一旦出现扩容情况，则 **容易出现环形链表**，从而在获取数据、遍历链表时形成死循环（Infinite Loop），即**线程不安全**。 + + + +## createEntry() + +```java +void createEntry(int hash, K key, V value, int bucketIndex) { + Entry e = table[bucketIndex]; + table[bucketIndex] = new Entry<>(hash, key, value, e); + size++; //这里才进行size++ + } +``` + +举个例子说明流程： + +1、假设hashmap中容量为16，加载因为为0.75 = 12。 + +2、此时hashmap中有11个元素，也就是size == 11，在你添加第12个元素时。看代码，此时size还是11，所以并不会扩容。只有在你调用完`createEntry()`,`size++`执行完毕后，size变成12。 + +3、在添加第13个元素时，才会进入if逻辑里进行先扩容。 + +```java + void addEntry(int hash, K key, V value, int bucketIndex) { + + if ((size >= threshold) && (null != table[bucketIndex])) { + resize(2 * table.length); + hash = (null != key) ? hash(key) : 0; + bucketIndex = indexFor(hash, table.length); + } + createEntry(hash, key, value, bucketIndex); + } +``` + + + + + +# 扩容出现的死循环链表 + +```java + /** + * 作用：将旧数组上的数据（键值对）转移到新table中，从而完成扩容 + * 过程：按旧链表的正序遍历链表、在新链表的头部依次插入。但是这样会导致扩容完成后，链表逆序 + */ +void transfer(Entry[] newTable, boolean rehash) { + int newCapacity = newTable.length; + //通过遍历 旧数组，将旧数组上的数据（键值对）转移到新数组中 + for (Entry e : table) { + while(null != e) { + /* + 1、遍历以该数组元素为首的链表 + 2、转移链表时，因是单链表，故要保存下1个结点，否则转移后链表会断开 + */ + Entry next = e.next; //pos_1 + if (rehash) { + e.hash = null == e.key ? 0 : hash(e.key); + } + //重新计算每个元素的存储位置 + int i = indexFor(e.hash, newCapacity); + + //这个地方暂时先放着，后面讲死循环链表的时候会讲到 + e.next = newTable[i]; + //讲当前元素，赋给新数组的对应下标位置。 + newTable[i] = e; + // 访问下1个Entry链上的元素，如此不断循环，直到遍历完该链表上的所有节点 + e = next; + } + } + } +``` + + + +## 前置条件 + +1、为了演示方便，初始状态时，hashmap容量为2，加载因子为默认的0.75. + + + + + +## 步骤1 + +**hashmap初始状态** + + + + + +1、此时只有一个元素，扩容阈值为2*0.75 = 1.5。 + +2、此时假设有两个线程，线程a和线程b同时put，并且都没有进入到addEntry()方法里的if逻辑【因为此时size都没有++，size == 1 1 < 1.5 所以if判断不成立。】。两个线程都准备同时调用createEntry()方法。 + +```java + void addEntry(int hash, K key, V value, int bucketIndex) { + + if ((size >= threshold) && (null != table[bucketIndex])) { + resize(2 * table.length); + hash = (null != key) ? hash(key) : 0; + bucketIndex = indexFor(hash, table.length); + } + createEntry(hash, key, value, bucketIndex); + } +``` + +3、线程a put的是 e3 = 。线程b put的是e2 = 。两个都调用了`createEntry()`方法。 + +## 步骤2 + +**两个线程调用完毕之后，hashmap目前是这样的。** + + + + + +此时size==3。下次再进行put的时候，**addEntry()方法里的if判断就会成立**。 + + + +## 步骤3 + +1、接着，又来了两个线程，线程1和线程2。【假设线程1put的是e1，线程2put的是e0。其实也不用管它们两put的是谁】 + +2、两个线程都同时调用resize()方法，新数组已经扩容完毕，准备转移旧数组上的数据到新数组里。也就是准备调用resize()里的下面这个方法。 + +``` +//5、将旧数组上的数据（键值对）转移到新table中，从而完成扩容 + transfer(newTable, initHashSeedAsNeeded(newCapacity)); +``` + +3、来看下此时内存里的状态 + + + + + +## 步骤4 + +来看下源码【上面源码里有注释，这里把注释去掉】 + + + +```java +void transfer(Entry[] newTable, boolean rehash) { + int newCapacity = newTable.length; + + for (Entry e : table) { + while(null != e) { + //pos_1 + Entry next = e.next; + if (rehash) { + e.hash = null == e.key ? 0 : hash(e.key); + } + int i = indexFor(e.hash, newCapacity); + //pos_2 + e.next = newTable[i]; + //pos_3 + newTable[i] = e; + //pos_4 + e = next; + } + } + } +``` + + + +1、假设线程1**执行完**代码pos_1位置后，暂时挂起。此时e == e2 e.next == e3 + +2、线程2直接**扩容完毕**，那么完成后的状态是这样【假设e2和e3还是hash到同一个位置】 + + + +3、线程1还是原来的状态 + +> 强调一点：线程2已经扩容完毕 + +## 步骤5 + +目前两个线程里的新数组是这样的 + + + +为了方便后面观看，我画成这样。 + + + + + +## 步骤6 + +```java +void transfer(Entry[] newTable, boolean rehash) { + int newCapacity = newTable.length; + for (Entry e : table) { + while(null != e) { + //pos_1 + Entry next = e.next; + if (rehash) { + e.hash = null == e.key ? 0 : hash(e.key); + } + int i = indexFor(e.hash, newCapacity); + //pos_2 + e.next = newTable[i]; + //pos_3 + newTable[i] = e; + //pos_4 + e = next; + } + } + } +``` + +> 之前说过：假设线程1**执行完**代码pos_1位置后，暂时挂起。此时e == e2 e.next == e3【也就是next == e3】 + +1、线程1唤醒后，继续执行pos_2，pos_3，pos_4 + +2、执行pos_2：意思是e2的next指针指向了线程1的新hash表【也就是newTable1】，因为newTable1是新的所以为null， + +所以e2.next = null。 + +3、执行pos_3：newTable1[3] = e2; + +4、执行pos_4： e = e3; + + + +也就变成了下面这个样子。 + + + + + + + +## 步骤7 + +1、线程1继续执行循环 + +> 注意之前强调过线程2已经扩容完毕，那么table就已经被指向了newTable2，也就是说第二次循环时，线程1所循环的table变量就是newTable2 + +2、 + +```java +void transfer(Entry[] newTable, boolean rehash) { + int newCapacity = newTable.length; + for (Entry e : table) { + while(null != e) { + //pos_1 + Entry next = e.next; + if (rehash) { + e.hash = null == e.key ? 0 : hash(e.key); + } + int i = indexFor(e.hash, newCapacity); + //pos_2 + e.next = newTable[i]; + //pos_3 + newTable[i] = e; + //pos_4 + e = next; + } + } + } +``` + +1、执行pos_1：此时e == e3，那么next就是 e3.next，此时next == e2； + +2、执行pos_2：经过第一轮循环，newTable1[3] == e2。那么执行完这行代码后，e3.next还是等于e2【相当于没执行】 + +3、执行pos_3：newTable1[3] == e3。 + +4、执行pos_4：e = e2 + +执行完，变成这样。 + + + + + + + +## 步骤8 + +线程1执行第三次循环 + +1、执行pos_1：next = e2.next得到 next == null。 + +2、执行pos_2： `e.next = newTable[i]` e2.next == newTable1[3]。也就是相当于 e2.next == e3 + +3、执行pos_3： newTable[i] = e得到 newTable1[3] == e2 + + + +这样就形成了循环链表，再get()数据就会陷入死循环。 + + + + + +# get()源码 + +```java + + public V get(Object key) { + + //当key==null时，则到table[0]为头结点的链表去寻找对应 key == null的键 + if (key == null) + return getForNullKey(); + + //当key ≠ null时，去获得对应值 + Entry entry = getEntry(key); + + return null == entry ? null : entry.getValue(); +} + + + + private V getForNullKey() { + + if (size == 0) { + return null; + } + + // 遍历以table[0]为头结点的链表，寻找 key==null 对应的值 + for (Entry e = table[0]; e != null; e = e.next) { + + // 从table[0]中取key==null的value值 + if (e.key == null) + return e.value; + } + return null; + } + + + final Entry getEntry(Object key) { + + if (size == 0) { + return null; + } + + //根据key值，通过hash（）计算出对应的hash值 + int hash = (key == null) ? 0 : hash(key); + + //根据hash值计算出对应的数组下标,遍历以该数组下标的数组元素为头结点的链表所有节点，寻找该key对应的值 + for (Entry e = table[indexFor(hash, table.length)]; e != null; e = e.next) { + + Object k; + // 若 hash值和key 相等，则证明该Entry = 我们要的键值对 + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) + return e; + } + return null; + } + +``` + diff --git a/docs/Java/collection/HashMap-JDK8源码讲解及常见面试题.md b/docs/Java/collection/HashMap-JDK8源码讲解及常见面试题.md new file mode 100644 index 0000000..bc4fe65 --- /dev/null +++ b/docs/Java/collection/HashMap-JDK8源码讲解及常见面试题.md @@ -0,0 +1,694 @@ +--- +title: HashMap-JDK8源码讲解及常见面试题 +tags: + - Java集合 + - HashMap +categories: + - Java集合 + - HashMap +keywords: Java集合，HashMap。 +description: HashMap-JDK8源码讲解及常见面试题。 +cover: 'https://cdn.jsdelivr.net/gh/youthlql/lql_img/Java_Basis/logo.png' +top_img: 'https://cdn.jsdelivr.net/gh/youthlql/lql_img/blog/top_img.jpg' +date: 2020-11-1 10:22:05 +--- + + + + + + + +> JDK7说过的东西，本篇文章不再讲解 + +# 数据结构 + +## 红黑树 + +在JDK8中，优化了HashMap的数据结构，引入了红黑树。即HashMap的数据结构：数组+链表+红黑树。HashMap变成了这样。 + + + +### 为什么要引入红黑树 + +1、主要是为了提高HashMap的性能，即解决发生hash冲突后，因为链表过长而导致索引效率慢的问题 + +2、链表的索引速度是O(n)，而利用了红黑树快速增删改查的特点，时间复杂度就是O(logn)。 + + + +## Node类 + +`HashMap`中的数组元素，链表节点均采用`Node`类 实现，与 `JDK 1.7` 的对比（`Entry`类），仅仅只是换了名字。 + +就是一些常规的方法 + +```java +/** + * Node = HashMap的内部类，实现了Map.Entry接口，本质是 = 一个映射(键值对) + * 实现了getKey()、getValue()、equals(Object o)和hashCode()等方法 + **/ + static class Node implements Map.Entry { + + final int hash; + final K key; + V value; + Node next; + + // 构造方法 + Node(int hash, K key, V value, Node next) { + this.hash = hash; + this.key = key; + this.value = value; + this.next = next; + } + + public final K getKey() { return key; } + public final V getValue() { return value; } + public final String toString() { return key + "=" + value; } + + public final V setValue(V newValue) { + V oldValue = value; + value = newValue; + return oldValue; + } + + public final int hashCode() { + return Objects.hashCode(key) ^ Objects.hashCode(value); + } + + public final boolean equals(Object o) { + if (o == this) + return true; + if (o instanceof Map.Entry) { + Map.Entry e = (Map.Entry)o; + if (Objects.equals(key, e.getKey()) && + Objects.equals(value, e.getValue())) + return true; + } + return false; + } + } + +``` + + + +## TreeNode类 + +```java + + static final class TreeNode extends LinkedHashMap.Entry { + + // 属性 = 父节点、左子树、右子树、删除辅助节点 + 颜色 + TreeNode parent; + TreeNode left; + TreeNode right; + TreeNode prev; + boolean red; + + // 构造函数 + TreeNode(int hash, K key, V val, Node next) { + super(hash, key, val, next); + } + + // 返回当前节点的根节点 + final TreeNode root() { + for (TreeNode r = this, p;;) { + if ((p = r.parent) == null) + return r; + r = p; + } + } + +``` + + + +## 重要参数 + +> JDK7里讲过的就不再讲了 + +```java + static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; + + static final int MAXIMUM_CAPACITY = 1 << 30; + + final float loadFactor; + + static final float DEFAULT_LOAD_FACTOR = 0.75f; + + int threshold; + + // 存储数据的Node类型 数组，长度 = 2的幂； + transient Node[] table; + transient int size; + + //与红黑树相关的参数 + + //单链表(桶)的树化阈值：即 链表转成红黑树的阈值，在存储数据时，当链表长度 > 该值时，则将链表转换成红黑树 + static final int TREEIFY_THRESHOLD = 8; + + /* + 1、桶的链表还原阈值：即 红黑树转为链表的阈值，当在扩容（resize（））时（此时HashMap的数据存储位置会重新计 算），在重新计算存储位置后，当原有的红黑树内节点数量 < 6时，则将 红黑树转换成链表 + */ + static final int UNTREEIFY_THRESHOLD = 6; + + /* + 1、最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才允许树形化链表 （即 将链表 转换成红黑树）。否则，若 （单链表）桶内元素太多时，则直接扩容，而不是树形化。 + 2、为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD + */ + static final int MIN_TREEIFY_CAPACITY = 64; + + +``` + + + +# 构造函数源码 + +```java + +public class HashMap + extends AbstractMap + implements Map, Cloneable, Serializable{ + + + public HashMap() { + this.loadFactor = DEFAULT_LOAD_FACTOR; + } + + public HashMap(int initialCapacity) { + this(initialCapacity, DEFAULT_LOAD_FACTOR); + + } + + /** + * 构造函数3：指定"容量大小"和"加载因子"的构造函数 + * 加载因子和容量由自己指定 + */ + public HashMap(int initialCapacity, float loadFactor) { + + // 指定初始容量必须非负，否则报错 + if (initialCapacity < 0) + throw new IllegalArgumentException("Illegal initial capacity: " + + initialCapacity); + + // HashMap的最大容量只能是MAXIMUM_CAPACITY，哪怕传入的 > 最大容量 + if (initialCapacity > MAXIMUM_CAPACITY) + initialCapacity = MAXIMUM_CAPACITY; + + // 填充比必须为正 + if (loadFactor <= 0 || Float.isNaN(loadFactor)) + throw new IllegalArgumentException("Illegal load factor: " + + loadFactor); + // 设置加载因子 + this.loadFactor = loadFactor; + + // 设置扩容阈值 + // 此处不是真正的阈值，仅仅只是将传入的容量大小转化为：>传入容量大小的最小的2的幂，该阈值后面会重新计算 + this.threshold = tableSizeFor(initialCapacity); + + } + + public HashMap(Map m) { + this.loadFactor = DEFAULT_LOAD_FACTOR; + + // 将传入的子Map中的全部元素逐个添加到HashMap中 + putMapEntries(m, false); + } +} + +``` + + + +## tableSizeFor() + +```java + /** + * 作用：将传入的容量大小转化为：>传入容量大小的最小的2的幂 + * 与JDK 1.7对比：类似于JDK 1.7 中 inflateTable()里的 roundUpToPowerOf2(toSize) + */ + 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; +} +``` + + + +```java + +public class test { + + public static void main(String[] args) { + int n = 65538; //这个数字是2^16 + 2 + System.out.println("开始:" + Integer.toBinaryString(n)); + int res = tableSizeFor(n); + System.out.println("最终结果:" + res); + } + + + static final int MAXIMUM_CAPACITY = 1 << 30; + + static final int tableSizeFor(int cap) { + int n = cap - 1; + n |= n >>> 1; + System.out.println(Integer.toBinaryString(n)); + n |= n >>> 2; + System.out.println(Integer.toBinaryString(n)); + n |= n >>> 4; + System.out.println(Integer.toBinaryString(n)); + n |= n >>> 8; + System.out.println(Integer.toBinaryString(n)); + n |= n >>> 16; + System.out.println(Integer.toBinaryString(n)); + return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; + } +} + +``` + +输出结果： + +``` +开始:10000000000000010 +11000000000000001 +11110000000000001 +11111111000000001 +11111111111111111 +11111111111111111 +最终结果:131072 + +Process finished with exit code 0 +``` + +**第一次运行：** + 10000000000000010 n >>> 1; + 01000000000000000 进行|运算 + 11000000000000001 +分析： + 把最大位的1，通过位移后移一位，并且通过|运算，组合起来 + +**第二次运行：** + 11000000000000001 n >>> 2; + 00110000000000000 进行|运算 + 11110000000000001 +分析： + 把最大的两位，已经变成1的，往后移动两位，并且通过|运算，组合起来 + +**第三次运行：** + 11110000000000001 n >>> 4; + 00001111000000000 进行|运算 + 11111111000000001 +分析： + 把最大4位，已经变成1的，往后移动4位，并且通过|运算，组合起来 + +**第四次运行：** + 11111111000000001 n >>> 8; + 00000000111111110 进行|运算 + 11111111111111111 +分析： + 把最大的8位，已经变成1的，往后移动8位，并且通过|运算，组合起来 + +**第五次运算：** + 同上。因为我的数据，最大只到17位，所有第五次没有效果。可以用32位来进行运算，第五次是通过前16位已经变成1的数据，往后移动16位，然后通过或运算，最后的结果是32位都变成1。 + +> 原理就是，保证造成一个所有位都为1的数据。并且通过最后的+1。变成2^N次方的数据。 + + + +# put源码 + +```java + public V put(K key, V value) { + //在第一个参数里就直接计算出了hash值 + return putVal(hash(key), key, value, false, true); + } +``` + + + +```java + final V putVal(int hash, K key, V value, boolean onlyIfAbsent, + boolean evict) { + Node[] tab; Node p; int n, i; + + + /* + 1、若哈希表的数组tab为空，则通过resize()进行初始化，所以，初始化哈希表的时机就是第1次调用put函数时， 即调用resize() 初始化创建。 + */ + if ((tab = table) == null || (n = tab.length) == 0) + n = (tab = resize()).length; + + /* if分支 + 1、根据键值key计算的hash值，计算插入存储的数组索引i + 2、插入时，需判断是否存在Hash冲突： + 2-1、若不存在（即当前table[i] == null），则直接在该数组位置新建节点，插入完毕。 + 2-2、否则代表发生hash冲突，进入else分支 + */ + if ((p = tab[i = (n - 1) & hash]) == null) + tab[i] = newNode(hash, key, value, null); + + else { + Node e; K k; + //判断 table[i]的元素的key是否与需插入的key一样，若相同则直接用新value覆盖旧value【即更新操作】 + if (p.hash == hash && + ((k = p.key) == key || (key != null && key.equals(k)))) + e = p; + + //继续判断：需插入的数据结构是否为红黑树 or 链表。若是红黑树，则直接在树中插入 or 更新键值对 + else if (p instanceof TreeNode) + /* + 1、putTreeVal作用：向红黑树插入 or 更新数据（键值对） + 2、过程：遍历红黑树判断该节点的key是否与需插入的key是否相同： + 2-1、若相同，则新value覆盖旧value + 2-2、若不相同，则插入 + */ + e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value); + + //进入到这个分支说明是链表节点 + else { + /* + 过程： + 1、遍历table[i]，判断Key是否已存在：采用equals()对比当前遍历节点的key 与 需插入数据的 key：若已存在，则直接用新value覆盖旧value + 2、遍历完毕后仍无发现上述情况，则直接在链表尾部插入数据(尾插法) + 3、新增节点后，需判断链表长度是否>8（8 = 桶的树化阈值）：若是，则把链表转换为红黑树 + */ + for (int binCount = 0; ; ++binCount) { + //对于2情况的操作 尾插法插入尾部 + if ((e = p.next) == null) { + p.next = newNode(hash, key, value, null); + //对于3情况的操作 + if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st + treeifyBin(tab, hash); + break; + } + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) + break; + p = e; + } + } + // 对1情况的后续操作：发现key已存在，直接用新value 覆盖 旧value，返回旧value + if (e != null) { // existing mapping for key + V oldValue = e.value; + if (!onlyIfAbsent || oldValue == null) + e.value = value; + afterNodeAccess(e); + return oldValue; + } + } + ++modCount; + // 插入成功后，判断实际存在的键值对数量size > threshold + if (++size > threshold) + resize(); + afterNodeInsertion(evict); + return null; + } +``` + + + +## hash() + +```java + + //JDK7实现:使用hashCode() + 4次位运算 + 5次异或运算（9次扰动） + static final int hash(int h) { + h ^= k.hashCode(); + h ^= (h >>> 20) ^ (h >>> 12); + return h ^ (h >>> 7) ^ (h >>> 4); + } + + //JDK8实现: 使用hashCode() + 1次位运算 + 1次异或运算（2次扰动） + static final int hash(Object key) { + int h; + /* + 1、当key = null时，hash值 = 0，所以HashMap的key可为null + 2、当key ≠ null时，则通过先计算出 key的 hashCode()（记为h），然后对哈希码进行扰动处理。高位参与 低位的运算：h ^ (h >>> 16) + */ + return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); + + } + +``` + +JDK8 hash的运算原理：高位参与低位运算，使得hash更加均匀。 + + + + + + + +## resize() + +这个方法改动比较大 + +```java + + //该函数有2种使用情况：1、初始化哈希表 2、当前数组容量过小，需扩容 + final Node[] resize() { + Node[] oldTab = table; // 扩容前的数组（当前数组） + int oldCap = (oldTab == null) ? 0 : oldTab.length; // 扩容前的数组的容量 + int oldThr = threshold;// 扩容前的数组的阈值 + int newCap, newThr = 0; + + // 针对情况2：若扩容前的数组容量超过最大值，则不再扩充 + if (oldCap > 0) { + if (oldCap >= MAXIMUM_CAPACITY) { + threshold = Integer.MAX_VALUE; + return oldTab; + } + + // 针对情况2：若无超过最大值，就扩充为原来的2倍 + else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && + oldCap >= DEFAULT_INITIAL_CAPACITY) + newThr = oldThr << 1; // 通过右移扩充2倍 + } + + // 针对情况1：初始化哈希表（采用指定值或者默认值） + else if (oldThr > 0) + newCap = oldThr; + + else { + newCap = DEFAULT_INITIAL_CAPACITY; + newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); + } + + // 计算新的扩容阈值 + if (newThr == 0) { + float ft = (float)newCap * loadFactor; + newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? + (int)ft : Integer.MAX_VALUE); + } + + threshold = newThr; + @SuppressWarnings({"rawtypes","unchecked"}) + Node[] newTab = (Node[])new Node[newCap]; + table = newTab; + + //旧数组数据移动到新数组里，整体过程也是遍历旧数组每个数据 + if (oldTab != null) { + // 把每个bucket都移动到新的buckets中 + for (int j = 0; j < oldCap; ++j) { + Node e; + if ((e = oldTab[j]) != null) { + oldTab[j] = null; + + if (e.next == null) + newTab[e.hash & (newCap - 1)] = e; + else if (e instanceof TreeNode) + ((TreeNode)e).split(this, newTab, j, oldCap); + + else { // 链表优化重hash的代码块 + Node loHead = null, loTail = null; + Node hiHead = null, hiTail = null; + Node next; + //这个待会细讲 + do { + next = e.next; + //原索引 + if ((e.hash & oldCap) == 0) { + if (loTail == null) + loHead = e; + else + loTail.next = e; + loTail = e; + } + // 原索引 + oldCap + else { + if (hiTail == null) + hiHead = e; + else + hiTail.next = e; + hiTail = e; + } + } while ((e = next) != null); + // 原索引放到bucket里 + if (loTail != null) { + loTail.next = null; + newTab[j] = loHead; + } + // 原索引+oldCap放到bucket里 + if (hiTail != null) { + hiTail.next = null; + newTab[j + oldCap] = hiHead; + } + } + } + } + } + return newTab; +} + +``` + + + +JDK8扩容时，数据在数组下标的计算方式 + + + +* `JDK8`根据此结论作出的新元素存储位置计算规则非常简单，提高了扩容效率。 + +- 这与 `JDK7`在计算新元素的存储位置有很大区别：`JDK7`在扩容后，都需按照原来方法进行rehash，效率不高。 + + + +# get源码 + +```java + + public V get(Object key) { + Node e; + // 计算需获取数据的hash值,通过getNode（）获取所查询的数据,获取后，判断数据是否为空 + return (e = getNode(hash(key), key)) == null ? null : e.value; + } + + +final Node getNode(int hash, Object key) { + Node[] tab; Node first, e; int n; K k; + + //计算存放在数组table中的位置 + if ((tab = table) != null && (n = tab.length) > 0 && + (first = tab[(n - 1) & hash]) != null) { + + // 先在数组中找，若存在，则直接返回 + if (first.hash == hash && // always check first node + ((k = first.key) == key || (key != null && key.equals(k)))) + return first; + + //若数组中没有，则到红黑树中寻找 + if ((e = first.next) != null) { + // 在树中get + if (first instanceof TreeNode) + return ((TreeNode)first).getTreeNode(hash, key); + + //若红黑树中也没有，则通过遍历，到链表中寻找 + do { + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) + return e; + } while ((e = e.next) != null); + } + } + return null; +} +``` + + + + + +# ---下面是常见面试题--- + +# HashMap在JDK7和8中区别？ + +1、hash冲突时：JDK7用的是头插法，而JDK1.8及之后使用的都是尾插法。JDK7是用单链表进行的纵向延伸，当采用头插法时会容易出现逆序且环形链表死循环问题。但是在JDK8之后是使用尾插法，能够避免出现逆序且链表死循环的问题。 + +2、扩容时：JDK7需要重新进行rehash。JDK8则直接时判断hash值新参与的位是0还是1，0就是原位置，1就是原位置+就容量 + +3、引入了红黑树（原因前面说过） + +4、hash的计算：JDK7是9次扰动（4次位运算 + 5次异或运算），JDK8时是2次扰动（1次位运算 + 1次异或运算）。 + +5、JDK7是先扩容再插入k-v，JDK8时是插入后一起扩容。 + +# 为什么不直接用hash码作为数组table的下标？ + +1、哈希码一般是int型，范围是-(2^31) -- 2^31 - 1。容易出现哈希码与数组大小范围不匹配的情况，即计算出来的哈希码可能不在数组大小范围内，从而导致无法匹配存储位置。 + +2、常见解决办法就是hash值与数组长度取模。 + +# 为什么容量要求为2的幂？ + +一般来说散列表容量的常规设计思路是容量取素数，因为素数导致冲突的概率 < 合数。比如Hashtable初始化容量就是11（不过扩容后不能保证是素数） + +**hashmap这样设计的原因是** + +1、保证哈希码的均匀性。首先容量可为奇数，也可为偶数。假设数组长度为奇数，那么二进制最后一位是1。假设数组长度为偶数，那么二进制最后一位是0。如果是奇数 hash&(length - 1) 铁定是偶数，就会导致浪费了数组的一半位置（奇数索引无法被放数据，hash冲突概率高）。如果是2的幂这种偶数，length - 1就是奇数，那么最终的hash&(length-1)计算出来的索引位置取决于hash值，也就是说可以是偶数索引，也可以是奇数索引，均匀分布。 + +2、length是2的幂时 hash&(length - 1)等价于hash % length。但是&效率更高，而只有length是2的幂，这两个才等价。 + + + +# 二次扰动的好处 + +高位充分参与低位运算，加大哈希码低位的随机性，使得分布更均匀，从而提高对应数组存储下标位置的随机性 & 均匀性，最终减少Hash冲突 + + + +# 什么样类型的数据适合做hashmap的key? + +像Integer这种，内部属性value被final修饰，保证了Hash值的不可更改性，有效的减少了hash冲突 + + + +# 为什么选择8作为树化阈值？ + +```java + //Java8代码官方解释的原因 + * Because TreeNodes are about twice the size of regular nodes, we + * use them only when bins contain enough nodes to warrant use + * (see TREEIFY_THRESHOLD). And when they become too small (due to + * removal or resizing) they are converted back to plain bins. In + * usages with well-distributed user hashCodes, tree bins are + * rarely used. Ideally, under random hashCodes, the frequency of + * nodes in bins follows a Poisson distribution + * (http://en.wikipedia.org/wiki/Poisson_distribution) with a + * parameter of about 0.5 on average for the default resizing + * threshold of 0.75, although with a large variance because of + * resizing granularity. Ignoring variance, the expected + * occurrences of list size k are (exp(-0.5) * pow(0.5, k) / + * factorial(k)). The first values are: + * + * 0: 0.60653066 + * 1: 0.30326533 + * 2: 0.07581633 + * 3: 0.01263606 + * 4: 0.00157952 + * 5: 0.00015795 + * 6: 0.00001316 + * 7: 0.00000094 + * 8: 0.00000006 + * more: less than 1 in ten million + +``` + +由于treenodes的大小大约是常规节点的两倍，因此我们仅在容器包含足够的节点以保证使用时才使用它们，当它们变得太小（由于移除或调整大小）时，它们会被转换回普通的node节点，容器中节点分布在hash桶中的频率遵循泊松分布，桶的长度超过8的概率非常非常小，作者是根据概率统计而选择了8作为阀值。 + + + +# 为什么选择6和8作为链表化和树化的阈值? + +1、首先就是遵循泊松分布概率选了6和8 + +2、其次：如果选择6和8（如果链表小于等于6树还原转为链表，大于等于8转为树），中间有个差值7可以有效防止链表和树频繁转换。假设一下，如果设计成链表个数超过8则链表转换成树结构，链表个数小于8则树结构转换成链表，如果一个HashMap不停的插入、删除元素，链表个数在8左右徘徊，就会频繁的发生树转链表、链表转树，效率会很低。 \ No newline at end of file diff --git a/docs/Java/concurrency/Java并发体系-第四阶段-AQS源码解读-[1].md b/docs/Java/concurrency/Java并发体系-第四阶段-AQS源码解读-[1].md index 6906465..b34090f 100644 --- a/docs/Java/concurrency/Java并发体系-第四阶段-AQS源码解读-[1].md +++ b/docs/Java/concurrency/Java并发体系-第四阶段-AQS源码解读-[1].md @@ -413,7 +413,7 @@ Process finished with exit code 0 - + AbstractOwnableSynchronizer AbstractQueuedLongSynchronizer