深入Java集合系列之三：HashMap

HashMap的工作原理概述

   HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

    在Java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

/**
* The table, resized as necessary. Length MUST Always be a power of two.
 */
transient Entry[] table;
 
static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    final int hash;
    ……
}

HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。

Entry就是数组中的元素，每个 Map.Entry 其实就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表。

哈希表

在数据结构中有一种称为哈希表的数据结构，它实际上是数组的推广。如果有一个数组，要最有效的查找某个元素的位置，如果存储空间足够大，那么可以对每个元素和内存中的某个地址对应起来，然后把每个元素的地址用一个数组（这个数组也称为哈希表）存储起来，然后通过数组下标就可以直接找到某个元素了。这种方法术语叫做直接寻址法。这种方法的关键是要把每个元素和某个地址对应起来，所以如果当一组数据的取值范围很大的时候，而地址的空间又有限，那么必然会有多个映射到同一个地址，术语上称为哈希冲突，这时映射到同一个地址的元素称为同义词。毕竟，存储空间有限，所以冲突是不可避免的，但是可以尽量做到减少冲突。目前有两种比较有效的方法来解决哈希冲突：

• 链地址法
• 开放地址法

链地址法

链地址法的大概思想是：对于每个关键字，使用哈希函数确定其在哈希表中位置（也就是下标），如果该位置没有元素则直接映射到该地址；如果该位置已经有元素了，就把该元素连接到已存在元素的尾部，也就是一个链表，并把该元素的next设置为null。这样的话，每个哈希表的位置都可能存在一个链表，这种方式要查找某个元素效率比较高，时间复杂度为O(1+a)，a为哈希表中每个位置链表的平均长度。这里需要假设每个元素都被等可能映射到哈希表中的任意一个位置。

下面这张图展示了链地址法的过程：

HashMap底层实现

HashMap允许使用null作为key或者value，并且HashMap不是线程安全的，除了这两点外，HashMap与Hashtable大致相同

当多个线程同时（严格来说不能称为同时，因为CPU每次只能允许一个线程获取资源，只不过时间上非常短，CPU运行速度很快，所以理解为同时）修改哈希映射，那么最终的哈希映射（就是哈希表）的最终结果是不能确定的，这只能看CPU心情了。如果要解决这个问题，官方的参考方案是保持外部同步，什么意思？看下面的代码就知道了：

Map m = Collections.synchronizedMap(new HashMap(...));

但是不建议这么使用，因为当多个并发的非同步操作修改哈希表的时候，最终结果不可预测，所以使用上面的方法创建HashMap的时候，当有多个线程并发访问哈希表的情况下，会抛出异常，所以并发修改会失败。比如下面这段代码：

public static void main(String[] args) {
		Map<Integer, String> collectionSynMap = Collections.synchronizedMap(new HashMap<Integer, String>());
		for (int i=0; i<20; i++){
		   collectionSynMap.put(i, String.valueOf(i));
		}
		Set<Entry<Integer, String>> keySets = collectionSynMap.entrySet();
		Iterator<Entry<Integer, String>> keySetsIterator = keySets.iterator();
		while(keySetsIterator.hasNext()){
			Entry<Integer, String> entrys = (Entry<Integer, String>)keySetsIterator.next();
			if(entrys.getValue().equals("4")){
				System.out.println(entrys.getValue());
				collectionSynMap.remove(4);
//				keySetsIterator.remove();
//				System.out.println(entrys);
			}
			System.out.println(entrys);
		}
	}
	

就会抛出ConcurrentModificationException异常，因为在使用迭代器遍历的时候修改映射结构，但是使用代码中注释的删除是不会抛出异常的。

通过上面的分析，我们初步了解HashMap的非线程安全的原理，下面从源码的角度分析一下，为什么HashMap不是线程安全的：

public V put(K key, V value) {
    //这里省略了对重复键值的处理代码
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

那么问题应该处在addEntry()上，下面来看看其源码：

void addEntry(int hash, K key, V value, int bucketIndex) {
    //如果达到Map的阈值，那么就扩大哈希表的容量
    if ((size >= threshold) && (null != table[bucketIndex])) {
        //扩容
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    //创建Entry键值对，此处省略这部分代码
}

假设有线程A和线程B都调用addEntry()方法，线程A和B会得到当前哈希表位置的头结点（就是上面链地址法的第一个元素），并修改该位置的头结点，如果是线程A先获取头结点，那么B的操作就会覆盖线程A的操作，所以会有问题。

下面再看看resize方法的源码：

void resize(int newCapacity) {
    //此处省略如果达到阈值扩容为原来两倍的过程代码
    Entry[] newTable = new Entry[newCapacity];
    //把当前的哈希表转移到新的扩容后的哈希表中
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

所以如果有多个线程执行put方法，并调用resize方法，那么就会出现多种情况，在转移的过程中丢失数据，或者扩容失败，都有可能，所以从源码的角度分析这也是线程不安全的。

HashMap测试代码

public static void main(String[] args) {
		Map<Integer, String> hashMap = new HashMap<Integer, String>();
		for (int i=0; i<20; i++){
			hashMap.put(i, String.valueOf(i));
		}
		Set<Entry<Integer, String>> keySets = hashMap.entrySet();
		final Iterator<Entry<Integer, String>> keySetsIterator = keySets.iterator();
		Thread t3 = new Thread(){
			public void run() {
				while(keySetsIterator.hasNext()){
					Entry<Integer, String> entrys = (Entry<Integer, String>)keySetsIterator.next();
					System.out.println(entrys.getValue());
					if(entrys.getValue().equals("1")){
						System.out.println(entrys.getValue());
						hashMap.remove(1);
					}
					
			    }
			
			}
		};
		Thread t4 = new Thread(){
			 public void run(){
				 while(keySetsIterator.hasNext()){
	                    Entry<Integer,String> entrys = (Entry<Integer, String>) keySetsIterator.next();
	                    System.out.println(entrys.getValue());
	                    if(entrys.getValue().equals("1")){
	                        System.out.println(entrys.getValue());
	                        hashMap.remove(1);
	                    }
	                }
			 }
		};
		t3.start();
		t4.start();
			
	}

这段代码启动了两个线程并发修改HashMap的映射关系，所以会抛出两个ConcurrentModificationException异常，通过这段测试代码在此证明了HashMap的非线程安全。