HashMap为什么哪里不安全?
比如一个 ArrayList 类,在添加一个元素的时候,它可能会有两步来完成:
1. 在 Items[Size] 的位置存放此元素;
2. 增大 Size 的值。
在单线程运行的情况下,如果 Size = 0,添加一个元素后,此元素在位置 0,而且 Size=1;
而如果是在多线程情况下,比如有两个线程,线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停,线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素,因为此时 Size 仍然等于 0 (注意哦,我们假设的是添加一个元素是要两个步骤哦,而线程A仅仅完成了步骤1),所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行,都增加 Size 的值。
那好,现在我们来看看 ArrayList 的情况,元素实际上只有一个,存放在位置 0,而 Size 却等于 2。这就是“线程不安全”了。
HashMap底层是一个Entry数组,当发生hash冲突的时候,hashmap是采用链表的方式来解决的,在对应的数组位置存放链表的头结点。对链表而言,新加入的节点会从头结点加入。
javadoc中关于hashmap的一段描述如下:
此实现不是同步的。如果多个线程同时访问一个哈希映射,而其中至少一个线程从结构上修改了该映射,则它必须 保持外部同步。(结构上的修改是指添加或删除一个或多个映射关系的任何操作;仅改变与实例已经包含的键关联的值不是结构上的修改。)这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象,则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作,以防止对映射进行意外的非同步访问
我们都知道HashMap是线程不安全的,在多线程环境中不建议使用,但是其线程不安全主要体现在什么地方呢,本文将对该问题进行解密。
1.jdk1.7中的HashMap
在jdk1.8中对HashMap做了很多优化,这里先分析在jdk1.7中的问题,相信大家都知道在jdk1.7多线程环境下HashMap容易出现死循环,这里我们先用代码来模拟出现死循环的情况:
public class HashMapTest { public static void main(String[] args) { HashMapThread thread0 = new HashMapThread(); HashMapThread thread1 = new HashMapThread(); HashMapThread thread2 = new HashMapThread(); HashMapThread thread3 = new HashMapThread(); HashMapThread thread4 = new HashMapThread(); thread0.start(); thread1.start(); thread2.start(); thread3.start(); thread4.start(); }}class HashMapThread extends Thread { private static AtomicInteger ai = new AtomicInteger(); private static Map map = new HashMap<>(); @Override public void run() { while (ai.get() < 1000000) { map.put(ai.get(), ai.get()); ai.incrementAndGet(); } }}
上述代码比较简单,就是开多个线程不断进行put操作,并且HashMap与AtomicInteger都是全局共享的。
在多运行几次该代码后,出现如下死循环情形:
其中有几次还会出现数组越界的情况:
这里我们着重分析为什么会出现死循环的情况,通过jps和jstack命名查看死循环情况,结果如下:
从堆栈信息中可以看到出现死循环的位置,通过该信息可明确知道死循环发生在HashMap的扩容函数中,根源在transfer函数中,jdk1.7中HashMap的transfer函数如下:
void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; for (Entry e : table) { while(null != e) { Entry 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; } } }
总结下该函数的主要作用:
在对table进行扩容到newTable后,需要将原来数据转移到newTable中,注意10-12行代码,这里可以看出在转移元素的过程中,使用的是头插法,也就是链表的顺序会翻转,这里也是形成死循环的关键点。
下面进行详细分析。
1.1 扩容造成死循环分析过程
前提条件,这里假设:
hash算法为简单的用key mod链表的大小。
最开始hash表size=2,key=3,7,5,则都在table[1]中。
然后进行resize,使size变成4。
- newTable[3]=e ----> newTable[3]=3e=next ----> e=7
- e=7next=e.next ----> next=3【从主存中取值】e.next=newTable[3] ----> e.next=3【从主存中取值】newTable[3]=e ----> newTable[3]=7e=next ----> e=3
- e=3next=e.next ----> next=nulle.next=newTable[3] ----> e.next=7 即:3.next=7newTable[3]=e ----> newTable[3]=3e=next ----> e=null
- e=5next=e.next ----> next=null,从主存中取值e.next=newTable[1] ----> e.next=5,从主存中取值newTable[1]=e ----> newTable[1]=5e=next ----> e=null
- final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node[] tab; Node p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) // 如果没有hash碰撞则直接插入元素 tab[i] = newNode(hash, key, value, null); else { Node e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }
在jdk1.7中,在多线程环境下,扩容时会造成环形链或数据丢失。
在jdk1.8中,在多线程环境下,会发生数据覆盖的情况。
未resize前的数据结构如下:
请点击输入图片描述
如果在单线程环境下,最后的结果如下:
请点击输入图片描述
这里的转移过程,不再进行详述,只要理解transfer函数在做什么,其转移过程以及如何对链表进行反转应该不难。
然后在多线程环境下,假设有两个线程A和B都在进行put操作。线程A在执行到transfer函数中第11行代码处挂起,因为该函数在这里分析的地位非常重要,因此再次贴出来。
请点击输入图片描述
此时线程A中运行结果如下:
请点击输入图片描述
线程A挂起后,此时线程B正常执行,并完成resize操作,结果如下:
请点击输入图片描述
这里需要特别注意的点:由于线程B已经执行完毕,根据Java内存模型,现在newTable和table中的Entry都是主存中最新值:7.next=3,3.next=null。
此时切换到线程A上,在线程A挂起时内存中值如下:e=3,next=7,newTable[3]=null,代码执行过程如下:
此时结果如下:
请点击输入图片描述
继续循环:
结果如下:
请点击输入图片描述
再次进行循环:
注意此次循环:e.next=7,而在上次循环中7.next=3,出现环形链表,并且此时e=null循环结束。
结果如下:
请点击输入图片描述
在后续操作中只要涉及轮询hashmap的数据结构,就会在这里发生死循环,造成悲剧。
1.2 扩容造成数据丢失分析过程
遵照上述分析过程,初始时:
请点击输入图片描述
线程A和线程B进行put操作,同样线程A挂起:
请点击输入图片描述
此时线程A的运行结果如下:
请点击输入图片描述
此时线程B已获得CPU时间片,并完成resize操作:
请点击输入图片描述
同样注意由于线程B执行完成,newTable和table都为最新值:5.next=null。
此时切换到线程A,在线程A挂起时:e=7,next=5,newTable[3]=null。
执行newtable[i]=e,就将7放在了table[3]的位置,此时next=5。接着进行下一次循环:
将5放置在table[1]位置,此时e=null循环结束,3元素丢失,并形成环形链表。并在后续操作hashmap时造成死循环。
请点击输入图片描述
2.jdk1.8中HashMap
在jdk1.8中对HashMap进行了优化,在发生hash碰撞,不再采用头插法方式,而是直接插入链表尾部,因此不会出现环形链表的情况,但是在多线程的情况下仍然不安全,这里我们看jdk1.8中HashMap的put操作源码:
这是jdk1.8中HashMap中put操作的主函数, 注意第6行代码,如果没有hash碰撞则会直接插入元素。
如果线程A和线程B同时进行put操作,刚好这两条不同的数据hash值一样,并且该位置数据为null,所以这线程A、B都会进入第6行代码中。
假设一种情况,线程A进入后还未进行数据插入时挂起,而线程B正常执行,从而正常插入数据,然后线程A获取CPU时间片,此时线程A不用再进行hash判断了,问题出现:线程A会把线程B插入的数据给覆盖,发生线程不安全。
总结
首先HashMap是线程不安全的,其主要体现:
这个的话不安全的地方有很多,比如说他的一系列问题就会造成很大的伤害,这些就是不安全的地方,虽然说也不是100%的不安全,但是还是注意安全是最好的。
1、HashMap线程不安全原因: 原因: JDK1.7 中,由于多线程对HashMap进行扩容,调用了HashMap#transfer (),具体原因:某个线程执行过程中,被挂起,其他线程已经完成数据迁移,等CPU资源释放后被挂起的线程重新执行之前的逻辑,数据已经被改变,造成死循环、数据丢失。
线程是进程中实施调度和分派的基本单位。一个进程可以有多个线程,但至少有一个线程;而一个线程只能在一个进程的地址空间内活动。内存资源分配给进程,同一个进程的所有线程共享该进程所有资源
有2种办法让hashmap线程安全,分别如下: 方法一:通过collections.synchronizedmap()返回一个新的map,这个新的map就是线程安全的
HashMap为什么不安全?
有两个原因 存放数据时,HashMap不是线程安全的 比如有两个线程A和B,首先A希望插入一个key-value对到HashMap中,首先计算记录所要落到的桶的索引坐标,然后获取到该桶里面的链表头结点,此时线程A的时间片用完了,而此时线程B被调度得以执行,和线程A一样执行,只不过线程B成功将记录插到了桶里面,...
HashMap为什么变成从尾部插入?
8采用的是尾插入法。 HashMap在jdk1.7中采用头插入法,在扩容时会改变链表中元素原本的顺序,以至于在并发场景下导致链表成环的问题。而在jdk1.8中采用尾插入法,在扩容时会保持链表元素原本的顺序,就不会出现 链表成环 的问题了。参考: HashMap之元素插入 , HashMap为何从头插入变成尾插入 ...
[笔记]为什么hashmap查询速度快? 如何理解hashmap的散列?
那么 hashmap 是通过hashcode进行散列,hashcode 是如何分组不得而知,但是原理也是一样,尽可能的平均分布 均匀 ,比如1万个数据如果 只有10个组,或者说 100个组里面数据全部在 第一个组,这效率还是一样 速度比简单粗暴的list 更慢了,为什么速度更慢了?比如1万个数据 分了100个组,但是...
hashmap为什么是线程不安全的
因为在jdk1.7中,在多线程环境下,扩容时会造成环形链或数据丢失、死循环。因为是链表结构,那么就很容易形成闭合的链路,这样在循环的时候只要有线程对这个HashMap进行get操作就会产生死循环。但是,我好奇的是,这种闭合的链路是如何形成的呢。在单线程情况下,只有一个线程对HashMap的数据结构进行操作...
hashmap算法复杂度为什么为O(1)
因为hashMap内部维护了一个Entry数组,hashcode即数组下标,根据key.hashcode()即可在数组中get到Entry对象,即O(1)。当然,这是理想情况。倘若数据量大,则可能发生hash碰撞,即一个hashcode可能对应多个key,这时候这个Entry数组中的元素就不是Entry了,而是一个Entry链表。调用map.get(key)的时候,遇到...
为什么hashmap线程不安全?
设计hashmap,与hashtable 的原因:已知线程同步需要消耗一定的时间来达到数据的一至性,hashmap中所有函数 没有去检查在其它线程中的使用情况下就进行操作了。所以导致了数据 操作结果不理想,但速度较快,适用使用在函数内部作为局部变量,hashtable 则所有函数声明了线程同步的 synchronized ,所以hashtable...
HashMap为什么存取效率那么高
1、出于并发性的考虑,同步保证多个进程不会同时修改一个对象,可以说,它是一种“锁”。 2、轻量这个词多用于微软的ActiveX,也许用在这并不恰当,但我只是想表达效率高、存储消耗小的意思。 3、在多个进程同时访问HashMap,并且其中一个进程修改...
为什么HashMap使用红黑树而不使用AVL树?
AVL也是logn;红黑树舍去了严格的平衡,使其插入,删除,查找的效率稳定在O(logn)反观AVL树,查找没问题O(logn),但是为了保证高度平衡,动态插入和删除的代价也随之增加,综合效率肯定达不到O(logn)所以在进行大量插入,删除操作时,红黑树更优一些 Hashmap用到数据结构有 数组,链表,红黑树 在没有...
hashmap 为什么线程不安全
有2种办法让HashMap线程安全,分别如下:方法一:通过Collections.synchronizedMap()返回一个新的Map,这个新的map就是线程安全的。 这个要求大家习惯基于接口编程,因为返回的并不是HashMap,而是一个Map的实现。方法二:重新改写了HashMap,具体的可以查看java.util.concurrent.ConcurrentHashMap. 这个方法比...
为什么面试要问hashmap 的原理?
“HashMap是基于hashing的原理,我们使用put(key, value)存储对象到HashMap中,使用get(key)从HashMap中获取对象。从这里开始,真正的困惑开始了,一些面试者会回答因为hashcode相同,所以两个对象是相等的,HashMap将会抛出异常,或者不会存储它们。然后面试官可能会提醒他们有equals()和hashCode两个方法,...
劳龙半水: HashMap底层是一个Entry数组,当发生hash冲突的时候,hashmap是采用链表的方式来解决的,在对应的数组位置存放链表的头结点.对链表而言,新加入的节点会从头结点加入.javadoc中关于hashmap的一段描述如下:此实现不是同步的....
云龙区13715479880: hashmap 为什么线程不安全 - ?
劳龙半水: 有2种办法让HashMap线程安全,分别如下:方法一:通过Collections.synchronizedMap()返回一个新的Map,这个新的map就是线程安全的. 这个要求大家习惯基于接口编程,因为返回的并不是HashMap,而是一个Map的实现.方法二:重新改写了HashMap,具体的可以查看java.util.concurrent.ConcurrentHashMap. 这个方法比方法一有了很大的改进.
云龙区13715479880: 为什么hashmap线程不安全 - ?
劳龙半水: 一直以来只是知道HashMap是线程不安全的,但是到底HashMap为什么线程不安全,多线程并发的时候在什么情况下可能出现问题?HashMap底层是一个Entry数组,当发生hash冲突的时候,hashmap是采用链表的方式来解决的,在对应的数组...
云龙区13715479880: 如何线程安全的使用HashMap - ?
劳龙半水: 在周二面试时,一面的面试官有问到HashMap是否是线程安全的,如何在线程安全的前提下使用HashMap,其实也就是HashMap,Hashtable,ConcurrentHashMap和synchronized Map的原理和区别.当时有些紧张只是简单说了下HashMap不是线...
云龙区13715479880: Java中,map分为哪些种类? - ?
劳龙半水: Map有:HashMap、TreeMap、Hashtable.1、HashMap:线程不安全,键、值不允许为null,并且没顺序.2、Hashtable:线程安全,键、值允许为null,并且没顺序.3、TreeMap:线程不安全、键、值不允许为null,并且没顺序. 备注:当前用的最多的是HashMap,因为线性不安全,也就是说读取和存储效率要更高一些.
云龙区13715479880: hashmap多线程为什么造成死循环 - ?
劳龙半水: 一直以来只是知道HashMap是线程不安全的,但是到底HashMap为什么线程不安全,多线程并发的时候在什么情况下可能出现问题? HashMap底层是一个Entry数组,当发生hash冲突的时候,hashmap是采用链表的方式来解决的,在对应的数组位置存放链表的头
云龙区13715479880: Hashtable跟HashMap的区别 Vector,ArrayList和List的异同 - ?
劳龙半水: 答:就ArrayList与Vector主要从二方面来说. 一.同步性:Vector是线程安全的,也就是说是同步的,而ArrayList是线程序不安全的,不是同步的 二.数据增长:当需要增长时,Vector默认增长为原来一培,而ArrayList却是原来的一半 就HashMap与HashTable主要从三方面来说. 一.历史原因:Hashtable是基于陈旧的Dictionary类的,HashMap是Java 1.2引进的Map接口的一个实现 二.同步性:Hashtable是线程安全的,也就是说是同步的,而HashMap是线程序不安全的,不是同步的 三.值:只有HashMap可以让你将空值作为一个表的条目的key或value
云龙区13715479880: 请教高手Hashtable、HashMap、HashSet的用法与区别? - ?
劳龙半水: 他们的区别:HashTable和HashMap是Map接口的实现类,其中HashTable的键或值不能为null,HashMap的键或值可以为null;HashTable是线程安全的,HashMap是线程不安全的,因此HashMap的效率要比HashTable高.HashSet是Set接口的实现...
云龙区13715479880: hashmap是线程安全还是不安全的 - ?
劳龙半水: String, Interger这样的wrapper类作为HashMap的键是再适合不过了,而且String最为常用.因为String是不可变的,也是final的,而且已经重写了equals()和hashCode()方法了.其他的wrapper类也有这个特点.不可变性是必要的,因为为了...
云龙区13715479880: javaAPI文档中写hashmap“此实现不是同步的”线程不安全而hashtable“此实现是同步的”线程安全?
劳龙半水: 意思是hashmap在多个线程同时操作时,结果会不可预料.而hashtable不会出现这个问题.具体原理你可以多了解一下多线程的东西.