open-source/JavaYouth
1
0
Fork 0
mirror of https://github.com/youthlql/JavaYouth.git synced 2026-03-14 05:43:50 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
9bacd452c9c4cc7c29c48df39a057e06ab55aedb
JavaYouth/docs/Java/collection/HashMap-JDK7源码讲解.md

1147 lines
34 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
---
title: HashMap-JDK7源码讲解
tags:
- Java集合
- HashMap
categories:
- Java集合
- HashMap
keywords: Java集合，HashMap。
description: HashMap-JDK7源码讲解。
cover: 'https://unpkg.zhimg.com/youthlql@1.0.8/Java_Basis/logo.png'
abbrlink: f1f58db2
date: 2020-11-01 10:21:58
---
> 本文基于版本 `JDK 1.7`，即 `Java 7`。
# HashMap用法
## 常用API
```java
V get(Object key); // 获得指定键的值
V put(K key, V value); // 添加键值对
void putAll(Map<? extends K, ? extends V> m); // 将指定Map中的键值对 复制到 此Map中
V remove(Object key); // 删除该键值对
boolean containsKey(Object key); // 判断是否存在该键的键值对；是 则返回true
boolean containsValue(Object value); // 判断是否存在该值的键值对；是 则返回true
Set<K> keySet(); // 单独抽取key序列，将所有key生成一个Set
Collection<V> 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
* <p>
* 功能描述:
*/
public class test {
//声明1个 HashMap的对象
static Map<String, Integer> 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<Map.Entry<String, Integer>> entrySet = map.entrySet();
// 2、遍历Set集合，从而获取key-value
for (Map.Entry<String, Integer> 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<String> 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采用的数据结构 = **数组（主） + 单链表（副）**
大致是这样的一个结构
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0001.png">
- 每个链表就算哈希表的桶（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<? extends K, ? extends V> 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<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, 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<K,V>[] table = (Entry<K,V>[]) 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<K,V> implements Map.Entry<K,V> {
final K key; // 键
V value; // 值
Entry<K,V> next; // 指向下一个节点 ，也是一个Entry对象，从而形成解决hash冲突的单链表
int hash; // hash值
/**
* 构造方法，创建一个Entry
* 参数：哈希值h，键值k，值v、下一个节点n
*/
Entry(int h, K k, V v, Entry<K,V> 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<K,V> m) {
}
/**
* 当从HashMap中删除了一个Entry时，会调用该函数
* 此处没做任何处理
*/
void recordRemoval(HashMap<K,V> m) {
}
}
```
`HashMap`中的数组元素 & 链表节点 采用 `Entry`类实现
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0001.png">
1、一个正方形代表一个Entry对象，同时也代表一个键值对。
2、即 `HashMap`的本质 = 1个存储`Entry`类对象的数组 + 多个单链表
3、Entry对象本质 = 1个映射（键 - 值对），属性包括：键（`key`）、值（`value`）、 下个节点( `next`) = 单链表的指针 = 也是一个`Entry`对象，用于解决`hash`冲突
# 构造函数源码
```java
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, 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<? extends K, ? extends V> 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<K,V> 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<K,V> 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<K,V> e : table) {
while(null != e) {
/*
1、遍历以该数组元素为首的链表
2、转移链表时，因是单链表，故要保存下1个结点，否则转移后链表会断开
*/
Entry<K,V> 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;
}
}
}
```
大概画了一下图：
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0002.png"/>
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0003.png">
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0004.png">
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0005.png">
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<K,V> 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<K,V> e : table) {
while(null != e) {
/*
1、遍历以该数组元素为首的链表
2、转移链表时，因是单链表，故要保存下1个结点，否则转移后链表会断开
*/
Entry<K,V> 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初始状态**
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0006.png">
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 = <k3,v3>。线程b put的是e2 = <k2,v2>。两个都调用了`createEntry()`方法。
## 步骤2
**两个线程调用完毕之后，hashmap目前是这样的。**
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0007.png">
此时size==3。下次再进行put的时候，**addEntry()方法里的if判断就会成立**。
## 步骤3
1、接着，又来了两个线程，线程1和线程2。【假设线程1put的是e1，线程2put的是e0。其实也不用管它们两put的是谁】
2、两个线程都同时调用resize()方法，新数组已经扩容完毕，准备转移旧数组上的数据到新数组里。也就是准备调用resize()里的下面这个方法。
```
//5、将旧数组上的数据（键值对）转移到新table中，从而完成扩容
transfer(newTable, initHashSeedAsNeeded(newCapacity));
```
3、来看下此时内存里的状态
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0008.png"/>
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0009.png">
## 步骤4
来看下源码【上面源码里有注释，这里把注释去掉】
```java
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
//pos_1
Entry<K,V> 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到同一个位置】
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0010.png">
3、线程1还是原来的状态
> 强调一点：线程2已经扩容完毕
## 步骤5
目前两个线程里的新数组是这样的
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0011.png">
为了方便后面观看，我画成这样。
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0012.png">
## 步骤6
```java
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
//pos_1
Entry<K,V> 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;
也就变成了下面这个样子。
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0013.png">
## 步骤7
1、线程1继续执行循环
> 注意之前强调过线程2已经扩容完毕，那么table就已经被指向了newTable2，也就是说第二次循环时，线程1所循环的table变量就是newTable2
2、
```java
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
//pos_1
Entry<K,V> 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
执行完，变成这样。
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0014.png">
## 步骤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
<img src="https://unpkg.zhimg.com/youthlql@1.0.8/Java_collection/HashMap/JDK7/0015.png">
这样就形成了循环链表，再get()数据就会陷入死循环。
# get()源码
```java
public V get(Object key) {
//当key==null时，则到table[0]为头结点的链表去寻找对应 key == null的键
if (key == null)
return getForNullKey();
//当key ≠ null时，去获得对应值
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
private V getForNullKey() {
if (size == 0) {
return null;
}
// 遍历以table[0]为头结点的链表，寻找 key==null 对应的值
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
// 从table[0]中取key==null的value值
if (e.key == null)
return e.value;
}
return null;
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
//根据key值，通过hash（）计算出对应的hash值
int hash = (key == null) ? 0 : hash(key);
//根据hash值计算出对应的数组下标,遍历以该数组下标的数组元素为头结点的链表所有节点，
//寻找该key对应的值
for (Entry<K,V> 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;
}
```
Reference in New Issue View Git Blame Copy Permalink