实战-深入剖析HashMap实现原理
HashMap是继承至AbstractMap,基于Map接口的一种哈希表的实现。
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
transient Entry[] table;
这里的transient表示定义了一个瞬时态变量。即不需要维持table的值,不想用serialization序列化机制来保存它
回顾Hibernate对象的3种状态,分别为:瞬时态(Transient)、 持久态(Persistent)、脱管态(Detached)。
1、瞬时态(Transient)对应的是通过new命令开辟内存空间的java对象,瞬时对象在内存孤立存在,如果没有变量对该对象进行引用,它将被java虚拟机回收。它不和数据库的数据有任何关联关系,在Hibernate中,可通过session的save()或saveOrUpdate()方法将瞬时对象与数据库相关联,并将数据对应的插入数据库中,此时该瞬时对象转变成持久化对象。
2、持久态(Persistent)则是在数据库中有对应记录的对象,与session关联。
3、脱管态(Detached),又称游离态,可以说在数据库中有对应记录的对象,但不与session关联。即是持久态对象关闭了session后的对象,但拥有数据库标识。相对于瞬时态而言,多了一个数据库记录标识值。
哈希算法则是将任意长度的输入(二进制)值映射为固定长度的输出(较小二进制)。运用hash算法加密比较著名的如:MD5,SHA-1加密,这些是不可逆的加密。(有一种简单的可逆加密算法:异或运算,原理:a^b=c;则有c^b=a)HashMap中则也是使用了hash算法来存储元素的
static int hash(int h) { h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } static int indexFor(int h, int length) { return h & (length-1); }
HashMap里的hash(int h)方法根据key的hashCode重新计算一次散列。此算法加入了高位计算,防止低位不变,高位变化时,造成的hash冲突。
而indexFor方法设计的巧妙之处在于用按位与来代替取模运算(位运算效率明显高于其他运算),但是这里的length必须是2的幂,这也是HashMap的容量设计capacity为什么一定要2的幂的原因。通过一个简单测试
public static void main(String[] args) { int a=75%16; int b=75&(16-1); System.out.println(a); System.out.println(b); }
测试结果
11
11
只要满足length是2的幂,h&(length-1)与h%length是等价的
hash和indexFor方法的作用,通过下图分析
hash的目的是让“1”变的均匀一些,散列的本意就是要尽量均匀分布元素,充分利用空间,也是方便在indexFor方法中拿到比较均匀的index。这也是因为HashMap的数据结构是数组和链表的结合,设计者就是想尽量地去一次性遍历数组拿到数据,降低去遍历链表的几率,从而大大地优化了查询效率。HashMap的数据结构图如下
对于Entry在HashMap中的设计是这样的
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next; final int hash;}
Entry就是HashMap里面定义的一个静态内部类,存放元素的键、值、hash值和指向下一个元素的next引用。
HashMap类相当于Hashtable,(除了Hashtable同步和不允许null)。HashMap不担保映射的顺序,特别是它不保证该顺序将随时间保持不变。
接下来介绍几个重要参数
/** * 默认初始容量(16)——必须是2的幂 */ static final int DEFAULT_INITIAL_CAPACITY = 16; /** * 如果使用的最大容量,更高的价值是隐式地指定 */ static final int MAXIMUM_CAPACITY = 1 << 30; /** * 当构造函数中没有指定时,默认的负载系数。 */ static final float DEFAULT_LOAD_FACTOR = 0.75f; /** * 扩容后的下一个大小值调整(容量*负载系数),极限值。 int threshold; /** * 哈希表的负载系数。 final float loadFactor; /** HashMap结构性修改的次数 */ transient volatile int modCount;
值得关注的是加了volatile修饰的modCount变量,这个变量是迭代器的快速失败原理fast-fail的运用,不会等到迭代结束再抛出异常。关于volatile的一些总结:
volatile原意:易变的;反复无常的;volatile修饰的变量是说这变量可能会被意想不到地改变,优化器每次都小心地重新去内存读取这个变量的值,而不是使用保存在寄存器里的备份。 volatile不具备原子性,volatile 变量不能用作线程安全计数器。虽然增量操作(x++)看上去类似一个单独操作,实际上它是一个由读取-修改-写入操作序列组成的组合操作,必须以原子方式执行,而 volatile 不能提供必须的原子特性。实现正确的操作需要使 x 的值在操作期间保持不变,而 volatile 变量无法实现这点。
volatile具备可见性,Volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。从而保证后一个拿到锁的线程读取到前一个线程修改后的值
modCount作用的核心代码如下
private abstract class HashIterator<E> implements Iterator<E> { Entry<K,V> next; // next entry to return int expectedModCount; // For fast-fail int index; // current slot Entry<K,V> current; // current entry HashIterator() { expectedModCount = modCount; if (size > 0) { // advance to first entry Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } } public final boolean hasNext() { return next != null; } final Entry<K,V> nextEntry() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); Entry<K,V> e = next; if (e == null) throw new NoSuchElementException(); if ((next = e.next) == null) { Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } current = e; return e; } public void remove() { if (current == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); Object k = current.key; current = null; HashMap.this.removeEntryForKey(k); expectedModCount = modCount; } }
通过研究源码,可以发现HashMap在添加、删除或修改元素时,都会执行modCount++,所有在使用迭代器遍历HashMap时,如果有其他线程对该HashMap进行了结构性的操作时,迭代器会发现并抛出ConcurrentModificationException异常
throw new ConcurrentModificationException();
而之前说的HashMap的容量是2的幂,这个又是怎么实现,怎么控制的呢?原理如下
int capacity = 1; while (capacity < initialCapacity) capacity <<= 1;//通过向右移位(每当capacity小于初始化构造方法是传入的<span style="font-family: verdana, sans-serif;">initialCapacity值是,capacity值都会翻倍</span>) this.loadFactor = loadFactor; threshold = (int)(capacity * loadFactor);//极限值=集合容量*负载系数 table = new Entry[capacity];//根据capacity指定容量大小,为Entry数组开辟一块内存空间
既然HashMap底层数据结构是基于数组+链表,但存储的元素越来越多时,就要涉及到扩容了,着也是HashMap里对效率影响最大的耗时操作。因为扩充过程会导致元素数据的所有元素进行重新hash计算,这个过程也叫rehash。因此尽可能的选择合适的初始化大小是有效提高HashMap效率的关键。太大了会导致过多的浪费空间,太小了就可能会导致繁重的rehash过程。在这个过程中loadFactor也可以考虑。负载因子越大,空间的利用率越高,但从统计学角度讲意味着链表的长度就也大,也就是在查找元素的时候就需要更多次的循环。所以凡事必然是一个平衡的过程。
接下来就分析下扩容的过程:
首先要有触发条件,也就是什么时候会导致扩容,根源如下:
void addEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<K,V>(hash, key, value, e); if (size++ >= threshold) resize(2 * table.length); }
但size数组大于threshold极限值是,调用resize,扩容两倍。接下来就进入resize方法
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]; transfer(newTable); table = newTable; threshold = (int)(newCapacity * loadFactor); } /** * Transfers all entries from current table to newTable. */ void transfer(Entry[] newTable) { Entry[] src = table; int newCapacity = newTable.length; for (int j = 0; j < src.length; j++) { Entry<K,V> e = src[j]; if (e != null) { src[j] = null; do { Entry<K,V> next = e.next; int i = indexFor(e.hash, newCapacity); e.next = newTable[i]; newTable[i] = e; e = next; } while (e != null); } } }
集合,最主要的作用其实就是对其所持有的某类型的数据进行存储和读取。
接下来就分析一下HashMap对元素的存取过程。
public V put(K key, V value) { if (key == null) return putForNullKey(value); int hash = hash(key.hashCode()); int i = indexFor(hash, table.length); 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++; addEntry(hash, key, value, i); return null; }
当我们往HashMap中put元素的时候,先根据key的hashCode重新计算hash值,根据hash值得到这个元素在 数组中的位置(即下标),如果数组该位置上已经存放有其他元素了,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放在链尾。如 果数组该位置上没有元素,就直接将该元素放到此数组中的该位置上。对于null元素,则一般是存放在index=0的首元素。
addEntry(hash, key, value, i)方法根据计算出的hash值,将key-value对放在数组table的i索引处。addEntry 是 HashMap 提供的一个包访问权限的方法。
public V get(Object key) { if (key == null) return getForNullKey(); int hash = hash(key.hashCode()); 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.equals(k))) return e.value; } return null; }
首先计算key的hashCode,找到数组中对应位置的某一元素,然后通过key的equals方法在对应位置的链表中找到需要的元素。