HashMap线程不安全体现在哪里？

淡淡的烟草味﹌ 2023-10-09 20:09 113阅读 0赞

![format_png][]

**HashMap线程不安全体现在哪里？如果你到现在还不清楚赶紧看下去，明明白白补一补~。**

在Java中，HashMap是一种常用的数据结构，它以键值对的形式存储和管理数据。然而，由于HashMap在多线程环境下存在线程安全问题，因此在使用时需要格外小心。

> 简单来说：在 **hashMap1.7 中扩容**的时候，因为采用的是头插法，所以会可能会有循环链表产生，导致数据有问题，在 1.8 版本已修复，改为了尾插法； 在任意版本的 hashMap 中，如果在**插入数据时多个线程命中了同一个槽**，可能会有数据覆盖的情况发生，导致线程不安全。

HashMap的线程不安全主要体现在以下两个方面：

#### 1. 并发修改导致数据不一致 ####

HashMap的数据结构是基于数组和链表实现的。在进行插入或删除操作时，如果不同线程同时修改同一个位置的元素，就会导致数据不一致的情况。具体来说，当两个线程同时进行插入操作时，假设它们都要插入到同一个数组位置，并且该位置没有元素，那么它们都会认为该位置可以插入元素，最终就会导致其中一个线程的元素被覆盖掉。此外，在进行删除操作时，如果两个线程同时删除同一个元素，也会导致数据不一致的情况。

以下是一个示例代码，展现了两个线程对HashMap进行并发修改的情况：

import java.util.HashMap;
    
    public class HashMapThreadUnsafeExample {
    
        public static void main(String[] args) throws InterruptedException {
            final HashMap<String, Integer> map = new HashMap<>();
    
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    map.put("key" + i, i);
                }
            });
    
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    map.put("key" + i, i * 2);
                }
            });
    
            t1.start();
            t2.start();
    
            t1.join();
            t2.join();
    
            System.out.println("map size: " + map.size());
        }
    }
    复制代码

上述示例代码中，t1线程和t2线程都向HashMap中插入数据，由于它们在进行插入操作时修改的是同一个位置的元素，因此最终导致了部分数据不一致的情况。例如，当t1线程插入了(key1, 1)以后，t2线程又插入了(key1, 2)，这就导致了(key1, 1)被覆盖掉，最终HashMap的大小只有10000而不是20000。

#### 2. 并发扩容导致死循环或数据丢失 ####

当HashMap的元素数量达到一定阈值时，它会触发扩容操作，即重新分配更大的数组并将原来的元素重新映射到新的数组上。然而，在进行扩容操作时，如果不加锁或者加锁不正确，就可能导致死循环或者数据丢失的情况。具体来说，当两个线程同时进行扩容操作时，它们可能会同时将某个元素映射到新的数组上，从而导致该元素被覆盖掉。此外，在进行扩容操作时，如果线程不安全地修改了next指针，就可能会导致死循环的情况。

以下是一个示例代码，展现了两个线程对HashMap进行并发扩容的情况：

import java.util.HashMap;
    
    public class HashMapThreadUnsafeExample {
    
        public static void main(String[] args) throws InterruptedException {
            final HashMap<String, Integer> map = new HashMap<>(2, 0.75f);
    
            map.put("key1", 1);
            map.put("key2", 2);
            map.put("key3", 3);
    
            Thread t1 = new Thread(() -> {
                for (int i = 4; i < 10000; i++) {
                    map.put("key" + i, i);
                }
            });
    
            Thread t2 = new Thread(() -> {
                for (int i = 4; i < 10000; i++) {
                    map.put("key" + i, i * 2);
                }
            });
    
            t1.start();
            t2.start();
    
            t1.join();
            t2.join();
    
            System.out.println("map size: " + map.size());
        }
    }
    复制代码

上述示例代码中，t1线程和t2线程都向HashMap中插入数据，并且HashMap被初始化为大小为2，负载因子为0.75，这就意味着HashMap在元素数量达到3时就会进行扩容操作。由于t1和t2线程同时进行扩容操作，它们有可能都将某个元素映射到新的数组上，导致该元素被覆盖掉。此外，在进行扩容操作时，如果线程不安全地修改了next指针，就可能会导致死循环的情况。

> **除了并发修改和并发扩容外，还有以下情况可能导致HashMap不安全：**

#### 3. 非线程安全的迭代器 ####

当使用非线程安全的迭代器遍历HashMap时，如果在遍历的过程中其他线程修改了HashMap的结构，就可能抛出ConcurrentModificationException异常。

以下是一个示例代码，展现了如何通过多线程遍历HashMap以及导致线程不安全的情况：

import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    public class HashMapThreadUnsafeExample {
    
        public static void main(String[] args) throws InterruptedException {
            final Map<String, Integer> map = new HashMap<>();
    
            for (int i = 0; i < 10000; i++) {
                map.put("key" + i, i);
            }
    
            Thread t1 = new Thread(() -> {
                Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
                while (iterator.hasNext()) {
                    System.out.println(iterator.next().getValue());
                }
            });
    
            Thread t2 = new Thread(() -> {
                for (int i = 10000; i < 20000; i++) {
                    map.put("key" + i, i);
                }
            });
    
            t1.start();
            t2.start();
    
            t1.join();
            t2.join();
        }
    }
    复制代码

上述示例代码中，t1线程遍历了HashMap中的元素，但并没有对其进行加锁保护。同时，在t1线程遍历的过程中，t2线程又进行了另外一部分元素的插入操作，这就导致了HashMap结构的不稳定性，最终可能会抛出ConcurrentModificationException异常。

#### 4. 非线程安全的比较器 ####

当使用非线程安全的比较器来定义HashMap的排序规则时，就可能导致在并发环境下出现数据不一致性的情况。

以下是一个示例代码，展现了如何通过多线程修改HashMap中元素顺序以及导致线程不安全的情况：

import java.util.Comparator;
    import java.util.HashMap;
    import java.util.Map;
    
    public class HashMapThreadUnsafeExample {
    
        public static void main(String[] args) throws InterruptedException {
            final Map<String, Integer> map = new HashMap<>();
    
            map.put("key1", 1);
            map.put("key2", 2);
            map.put("key3", 3);
    
            Comparator<String> comparator = (s1, s2) -> {
                int i1 = Integer.parseInt(s1.substring(3));
                int i2 = Integer.parseInt(s2.substring(3));
                return Integer.compare(i1, i2);
            };
    
            Thread t1 = new Thread(() -> {
                for (int i = 4; i < 10000; i++) {
                    map.put("key" + i, i);
                }
            });
    
            Thread t2 = new Thread(() -> {
                for (int i = 4; i < 10000; i++) {
                    map.put("key" + i, i * 2);
                }
            });
    
            t1.start();
            t2.start();
    
            t1.join();
            t2.join();
    
            System.out.println("map: " + map);
        }
    }
    复制代码

上述示例代码中，HashMap的排序规则使用了一个基于字符串处理的比较器来定义。当t1线程和t2线程同时进行插入操作时，由于它们在不同的元素上执行修改操作，因此并不会出现ConcurrentModificationException异常。然而，由于比较器不是线程安全的，当t1和t2线程同时进行对相同的元素值进行赋值操作时，就可能导致HashMap结构的不稳定性。例如，当t1线程将"key5"的值修改为5时，t2线程可能只修改到"value"字段的一部分，因此最终HashMap中的值可能出现混乱的情况。

写到这里我想告诉大家：HashMap在多线程环境下存在线程安全问题，具体表现为并发修改导致数据不一致和并发扩容导致死循环或数据丢失。因此，在使用HashMap时需要采取相应的线程安全措施，例如使用ConcurrentHashMap、加锁等。

[format_png]: https://img-blog.csdnimg.cn/img_convert/01f4e22569a1ab59335c5da30c6680ab.webp?x-oss-process=image/format,png

发表评论取消回复

表情：

评论列表（有 0 条评论，113人围观）

还没有评论，来说两句吧...

相关阅读

相关详解HashMap线程不安全体现在哪里？

![format_png][] HashMap线程不安全体现在哪里？如果你到现在还不清楚赶紧看下去，明明白白补一补~。在Java中，HashMap是一种常用的数据结构，它

Myth丶恋晨/ 2024年03月22日 09:46/ 0 赞/ 141 阅读

相关 HashMap线程不安全体现在哪里？

![format_png][] HashMap线程不安全体现在哪里？如果你到现在还不清楚赶紧看下去，明明白白补一补~。在Java中，HashMap是一种常用的数据结构，它

Love The Way You Lie/ 2024年03月22日 09:46/ 0 赞/ 128 阅读

相关 HashMap线程不安全体现在哪里？

![format_png][] HashMap线程不安全体现在哪里？如果你到现在还不清楚赶紧看下去，明明白白补一补~。在Java中，HashMap是一种常用的数据结构，它

淡淡的烟草味﹌/ 2023年10月09日 20:09/ 0 赞/ 114 阅读

相关 HashMap线程不安全体现在哪里？

在Java中，HashMap是一种常用的数据结构，它以键值对的形式存储和管理数据。然而，由于HashMap在多线程环境下存在线程安全问题，因此在使用时需要格外小心。 > 简单

深碍√TFBOYSˉ_/ 2023年09月26日 23:22/ 0 赞/ 205 阅读

相关 HashMap为什么线程不安全

学习java集合时，老师都会说下hashMap是线程不安全的；现在就详细说下为什么不安全？ 1.put操作造成线程不安全这个问题比较好想象，比如有两个线程A和B，首先A希

心已赠人/ 2023年02月10日 15:26/ 0 赞/ 102 阅读

相关 hashmap为什么线程不安全_HashMap 为什么线程不安全？

> 作者：developer > > 来源：https://www.cnblogs.com/developer\_chan/p/10450908.html 前言：我们都知道

傷城~/ 2023年01月10日 13:06/ 0 赞/ 332 阅读

相关 HashMap为什么线程不安全?

一、学习目标 1、HashMap线程不安全原因：原因： JDK1.7 中，由于多线程对HashMap进行扩容，调用了HashMap\transfer()，具体

￡神魔★判官ぃ/ 2022年10月27日 13:56/ 0 赞/ 300 阅读

相关 HashMap为什么线程不安全？

一、hash碰撞导致 HashMap的底层存储结构，HashMap底层是一个Entry数组，一旦发生Hash冲突的的时候，HashMap采用拉链法解决碰撞冲突，Entry

清疚/ 2022年05月19日 03:48/ 0 赞/ 331 阅读

相关 HashMap 为什么线程不安全？

点击上方 [Java后端][Java]，选择设为星标优质文章，及时送达 -------------------- 前言：我们都知道HashMap是线程不安全的，在多线

浅浅的花香味﹌/ 2021年08月28日 22:57/ 0 赞/ 508 阅读

相关 HashMap 线程不安全的体现

前言：我们都知道HashMap是线程不安全的，在多线程环境中不建议使用，但是其线程不安全主要体现在什么地方呢，本文将对该问题进行解密。 1. jdk1.7中的HashMap

忘是亡心i/ 2021年08月19日 13:08/ 0 赞/ 457 阅读