title: HashMap源码分析
date: 2016-04-26
categories: java
tags: HashMap
1 HashMap概述
HashMap是基于哈希表的Map接口非同步实现（HashTable是同步的），允许null键和null值，但是不保证映射顺序（即不保证插入的顺序，LinkedHashMap有保证Map顺序的机制），不保证HashMap中数据的恒久不变。
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable{}
同步方式 ()：
Map<K, V> map = (Map<K, V>) Collections.synchronizedMap(new HashMap<>());
//或者用:
ConcurrentHashMap<K, V> map = new ConcurrentHashMap<>();
//ConcurrentHashMap融合了hashtable和hashmap二者的优势， hashtable同步时会锁住整个链表结构，ConcurrentHashMap则是使用了分段锁，效率较高 。
2 HashMap的数据结构
HashMap基于数组和链表实现。HashMap通过key的hashCode来计算hash值，只要hashCode相同，则hash值相同（hash冲突），则将相同hash值得元素存放到同一个链表中。
从图中可以看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表，链表中每一项是一个Entry<K,V>
看看HashMap中的Entry类
/** Entry是单向链表。
* 它是 HashMap链式存储法 对应的链表。
*它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些方法
**/
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next; //指向下一个节点
int hash;
/**
* 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;
}
/*
判断两个Entrry是否相等
若两个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: 按位异或 :1001 ^ 1100 = 0101
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
//向HashMap中添加元素，会调用这个方法
void recordAccess(HashMap<K,V> m) {
}
//从HashMap中删除元素，会调用这个方法
void recordRemoval(HashMap<K,V> m) {
}
}
这里分析下Map接口
public interface Map<K,V> {
int size();
boolean isEmpty();
boolean containsKey(Object key);
boolean containsValue(Object value);
V get(Object key);
V put(K key, V value);
V remove(Object key);
void putAll(Map<? extends K, ? extends V> m);
void clear();
Set<K> keySet();
Collection<V> values();
Set<Map.Entry<K, V>> entrySet();
//Map中的链表接口
interface Entry<K,V> {
K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
}
boolean equals(Object o);
int hashCode();
}
HashMap就是一个Entry数组，每个Entry链表中包含了键值对，处理冲突的方法就是拉链法
3 源码分析
3.1 基本数据
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 ： 2的4次方（左移动）
static final int MAXIMUM_CAPACITY = 1 << 30;//2的30方
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 存储元素实体的数组
static final Entry<?,?>[] EMPTY_TABLE = {};
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//元素个数
transient int size;
//临界值 当实际大小超过临界值时，会进行扩容threshold = 加载因子*容量
int threshold;
//负载因子
final float loadFactor;
//被修改的次数
transient int modCount;
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
负载因子默认值是0.75，若负载因子越大，填满的元素越多空间利用率越高，但是冲突的机会越大（链表长度变长，查找效率变低）。反之，负载因子较小时，冲突少了，但空间利用率降低了。
3.2 构造方法
//构造1 ： 指定初始容量和负载因子
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//isNaN : 0/0
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;
init();
}
//构造2 :指定初始容量 //默认负载因子 0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//构造3 ：
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//构造4 ：由给定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);
putAllForCreate(m);
}
3.3 put方法
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//若key为null,则将该键值对添加到table[0]中。具体看后面的putForNullKey方法
if (key == null)
return putForNullKey(value);
//若key不为null，则计算key的hash，
int hash = hash(key);
//搜索key的hash在table中的索引
int i = indexFor(hash, table.length);
//循环遍历Entry数组，若key对应的键已经存在，则将新的value赋值给旧的value，
// 然后退出
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;
}
}
//不存在重复的key，则 ：修改次数+1
modCount++;
//将key-value 添加到指定索引处 ： table[i], 参考后面的 addEntry（）
addEntry(hash, key, value, i);
return null;
}
private void inflateTable(int toSize) {
// Find a power of 2 >= toSize
///确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂
int capacity = roundUpToPowerOf2(toSize);
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
//存储key为null
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
//如果key为null的对象存在，则覆盖并返回
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//否则添加key为null的 key-value
modCount++;
addEntry(0, null, value, 0);
return null;
}
上面程序中 ： 每个Map.Entry就是一个key-value对。每当系统决定存在key-valu时，完全没有考虑Map.Entry中的value，仅仅根据key值进行计算。
key的hash计算方法：
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
int i = indexFor(hash, table.length);中的搜索指定hash值得方法 ：
static int indexFor(int h, int length) {
//根据key的hash值和数组长度计算
return h & (length-1);
}
这里要求数组长度是2的整数此幂。length为2的整数次幂的话，h&(length-1)就相当于对length取模（？），这样便保证了散列的均匀，同时也提升了效率；其次，length为2的整数次幂的话，为偶数，这样length-1为奇数，奇数的最后一位是1，这样便保证了h&(length-1)的最后一位可能为0，也可能为1（这取决于h的值），即与后的结果可能为偶数，也可能为奇数，这样便可以保证散列的均匀性，而如果length为奇数的话，很明显length-1为偶数，它的最后一位是0，这样h&(length-1)的最后一位肯定为0，即只能为偶数，这样任何hash值都只会被散列到数组的偶数下标位置上，这便浪费了近一半的空间，因此，length取2的整数次幂，是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列（参考）。
下面看看 addEntry 方法
void addEntry(int hash, K key, V value, int bucketIndex) {
//大于临界值 以2倍扩容
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
//如果要加入的位置有值，，该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点
createEntry(hash, key, value, bucketIndex);
}
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++;
}
调整大小 ：
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
//用来将原先table的元素全部移到newTable里面
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
//重新计算临界值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，扩容是需要进行数组复制的，复制数组是非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
3.4 get
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
//或得key为null的值
private V getForNullKey() {
if (size == 0) {
return null;
}
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
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 hashMap出现死锁的原因
参考 ：
http://github.thinkingbar.com/hashmap-infinite-loop/
http://my.oschina.net/xianggao/blog/393990#OSC_h2_9
HashMap出现死锁实在transfer方法调用时。当HashMap容量不够时，会在resize中调用找这个方法：
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
//对原数组遍历
for (Entry<K,V> e : table) { //这个table是初始的数组
while(null != e) {
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;
e = next;
}
}
}
这个方法实现数组的rehash ：
1 . 遍历原始数组
2. 对链表中中的每一个元素：用了next取得要专一那个元素e的下一个，将e转移到新的hash表的头部，现将e.next指向新hash表的第一个元素，这时候新的hash表的第一个元素是e，然后将hash表的的第一个元素指向e，
3. 循环
经过这几步，我们会发现转移的时候是逆序的。假如转移前链表顺序是1->2->3，那么转移后就会变成3->2->1。死锁问就是因为1->2的同时2->1造成的。所以，HashMap 的死锁问题就出在这个transfer()函数上。
当多个线程同时要求同时rehash时 则会出现死锁。
4 transient关键字的理解
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
transient int size;
transient int modCount;
在HashMap的定义中，初始数组 table size modCount都加了关键字 transient。在java中transient表示：当一个对象序列化时，指定的变量不在序列化范围中，也就没法持久化。
原因是 ：
读写Map是根据object的hashCode()来确定 从 table[i]读写，而 hashCode() 是本地化 native方法，在不同的JVM中可能不一样。这样导致序列化后，在不同的虚拟机上反序列化得知可能和原始值不同，也就失去了序列化的意义。
hashMap不使用默认的序列化机制， HashMap的readObject和writeObject把内容 输出/输入, 把HashMap重新生成出来。
下一步分析 ：
1 HashMap并发的替代方法
2 concurrentModificationException分析
参考 ：