前言
HashMap不是线程安全的，如果需要在多线程环境中使用Map，那么我们可以使用ConcurrentHashmap。
1.举例说明：
package com.test; import java.util.HashMap;
import java.util.UUID; public class Test {
public static void main(String[] args) throws InterruptedException { final HashMap<String, String> map = new HashMap<String, String>(2); for (int i = 0; i < 10000; i++) { new Thread(new Runnable() { @Override
public void run() {
System.out.println(UUID.randomUUID().toString());
map.put(UUID.randomUUID().toString(), "");
} }, "线程Thread-" + i).start(); } }
}
执行结果：
通过运行该段代码，过一段时间之后就会显示CPU使用率100%。
2.分析原因：
毫无疑问，因为陷入了死循环所以才会出现CPU使用达到100%的情况。可是为什么会出现死循环呢？知己知彼百战百胜，所以我们需要知道HashMap的原理所在，看源码。
2.1 HashMap结构
HashMap通常会用一个指针数组（假设为table[]）来做分散所有的key，当一个key被加入时，会通过Hash算法通过key算出这个数组的下标i，然后就把这个<key, value>插到table[i]中，如果有两个不同的key被算在了同一个i，那么就叫冲突，又叫碰撞，那么在同一个位子上的元素将以链表的形式存放，新加入的放在链头，而先前加入的放在链尾，这样会在table[i]上形成一个链表。最坏的情况下，所有的key都映射到同一个桶中，这样hashmap就退化成了一个链表——查找时间从O(1)到O(n)。Hash表这个容器当有数据要插入时，都会检查容量有没有超过设定的thredhold，如果超过，需要增大Hash表的尺寸，但是这样一来，整个Hash表里的无素都需要被重算一遍。这叫rehash，这个成本相当的大。
如代码所示：
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);
//查看当前的size是否超过了我们设定的阈值threshold，如果超过，需要resize
if (size++ >= threshold)
resize(2 * table.length);
}
2.2 resieze() 操作
如代码所示，如果现在size已经超过了threshold，那么就要进行resize操作,新建一个更大尺寸的hash表，然后把数据从老的Hash表中迁移到新的Hash表中：
resize(newCapacity)：
void resize(int newCapacity)
{
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
......
//创建一个新的Hash Table
Entry[] newTable = new Entry[newCapacity];
//将Old Hash Table上的数据迁移到New Hash Table上
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
transfer(Entry[] newTable)：
void transfer(Entry[] newTable)
{
Entry[] src = table;
int newCapacity = newTable.length;
// 从OldTable里摘一个元素出来，然后放到NewTable中
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);
}
}
}
2.3冲突产生
注意代码：
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);
如果有两个线程同时访问到这个循环操作，也就是说两个线程同时触发了rehash()操作之后：(对于这个例子假设初始容量为2，使用的Hash算法是取摸计算)
首先需要说明的是线程T1和线程T2同时访问到上面的代码，T1指向当前对象e,然后被挂起所以T2指向了Next对象，这也是为什么扩容后看到链表的顺序被反转。在第三i部就会形成一个局部链表，但我们在这个Map中放入元素11的时候会寻找到table[3]这个位置，然后就会陷入无休止的死循环中，这样，就不难解释CPU达到100%的原因了。（PS:图画的很丑）
3.其他扩展
针对HashMap退化成单链表的问题，在JDK8中有所改善。如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，查取元素时的花费是O(logn)，而不是糟糕的O(n)。它是如何工作的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。