Java基础：为什么hashmap是线程不安全的？-Toy模板网

这篇具有很好参考价值的文章主要介绍了Java基础：为什么hashmap是线程不安全的？。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

原因

HashMap 是线程不安全的主要原因是它的内部结构和操作不是线程安全的。下面是一些导致 HashMap 线程不安全的因素：

非同步操作：HashMap 的操作不是线程同步的，也就是说，在多线程环境下同时对 HashMap 进行读写操作可能会导致数据不一致的问题。
非原子操作：HashMap 的操作不是原子性的，例如 put() 方法涉及到了多个步骤，包括计算哈希值、查找或插入元素等。如果多个线程同时执行这些操作，就有可能导致数据不一致的情况。
容量扩容：HashMap 在扩容时，需要重新计算元素的哈希值并重新分配存储位置，这个过程涉及到对原数组进行复制和重新插入元素的操作。如果在扩容期间有其他线程对 HashMap 进行并发修改，就可能导致数据丢失或出现异常。

综上所述，由于 HashMap 的非同步和非原子性操作，以及容量扩容的复制和插入过程，使得它在多线程环境下容易出现线程安全问题。如果多个线程同时对 HashMap 进行读写操作，可能会导致数据不一致、数据丢失或出现异常的情况。

为了在多线程环境下安全地使用 HashMap，可以采取以下几种方式：

使用同步机制：可以使用线程安全的 Map 实现，如 ConcurrentHashMap，或者通过在访问 HashMap 时使用 synchronized 或其他锁机制来确保同一时间只有一个线程能够修改 HashMap。
使用并发容器：可以使用线程安全的并发容器，如 ConcurrentMap 或 CopyOnWriteMap，它们提供了并发访问的能力，适用于读多写少的场景。
使用线程封闭：可以将 HashMap 封闭在单个线程中，通过使用 ThreadLocal 或将 HashMap 作为局部变量在每个线程中进行操作，从而避免多线程访问导致的线程安全问题。

总之，如果需要在多线程环境中使用 Map，应该考虑使用线程安全的 Map 实现或采取适当的同步机制来确保线程安全性。

举例佐证

假设有两个线程同时对一个 HashMap 进行读写操作，下面是一个简单的示例来说明 HashMap 的线程不安全性：

import java.util.HashMap;

public class HashMapExample {
    private static HashMap<Integer, String> map = new HashMap<>();

    public static void main(String[] args) {
        // 创建并启动两个线程
        Thread thread1 = new Thread(new WriteTask());
        Thread thread2 = new Thread(new ReadTask());
        thread1.start();
        thread2.start();
    }

    static class WriteTask implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                map.put(i, "Value " + i);
                System.out.println("Thread 1: Added " + i);
            }
        }
    }

    static class ReadTask implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                if (map.containsKey(i)) {
                    String value = map.get(i);
                    System.out.println("Thread 2: Read " + value);
                }
            }
        }
    }
}

在上述示例中，WriteTask 线程通过循环向 HashMap 中添加元素，而 ReadTask 线程通过循环从 HashMap 中读取元素。由于 HashMap 不是线程安全的，当两个线程同时进行读写操作时，就可能出现数据不一致的情况。

运行示例代码，你会发现在控制台输出中可能会出现如下情况：

Thread 2: Read Value 0
Thread 2: Read Value 2
Thread 1: Added 1
Thread 2: Read Value 1

在这个例子中，Thread 2 在读取到某个键的值之后，Thread 1 可能会同时修改这个键的值，导致 Thread 2 读取到的值与期望不一致。

因此，这个例子展示了 HashMap 在多线程环境下的线程不安全性，这也是为什么在并发场景中应该使用线程安全的 Map 实现或采取适当的同步机制来确保线程安全性。

想想看，上述代码有问题吗？

使用CountDownLatch解决

上述示例代码存在问题，可能导致 Thread 2 没有输出任何内容。原因是在 Thread 1 启动后，可能会在 Thread 2 开始执行之前完成所有的写操作，因此 Thread 2 没有机会读取到任何值。

为了解决这个问题，可以使用 CountDownLatch 来同步两个线程的执行，确保 Thread 2 在 Thread 1 完成写操作后再开始读取。以下是修正后的示例代码：

import java.util.HashMap;
import java.util.concurrent.CountDownLatch;

public class HashMapExample {
    private static HashMap<Integer, String> map = new HashMap<>();
    private static CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) {
        // 创建并启动两个线程
        Thread thread1 = new Thread(new WriteTask());
        Thread thread2 = new Thread(new ReadTask());
        thread1.start();
        thread2.start();
    }

    static class WriteTask implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 1000; i++) {
                    map.put(i, "Value " + i);
                    System.out.println("Thread 1: Added " + i);
                }
            } finally {
                latch.countDown();
            }
        }
    }

    static class ReadTask implements Runnable {
        @Override
        public void run() {
            try {
                latch.await();
                for (int i = 0; i < 1000; i++) {
                    if (map.containsKey(i)) {
                        String value = map.get(i);
                        System.out.println("Thread 2: Read " + value);
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

修正后的代码使用 CountDownLatch 在 Thread 1 完成写操作后释放等待，使得 Thread 2 可以开始读取操作。这样就可以确保在读取之前所有的写操作都已经完成，从而避免了数据不一致的问题。

现在运行示例代码，你会看到 Thread 2 输出了与 Thread 1 写入的相应值，确保了线程安全性。

请注意，这只是一个简单的示例来说明 HashMap 的线程不安全性，并非使用 HashMap 的推荐方式。在实际应用中，应该使用线程安全的 Map 实现，如 ConcurrentHashMap，来保证线程安全性。

使用join方法

使用join等待两个线程运行结束，依旧存在问题：

import java.util.HashMap;

public class HashMapExample {
    private static HashMap<Integer, String> map = new HashMap<>();

    public static void main(String[] args) throws InterruptedException {
        // 创建并启动两个线程
        Thread thread1 = new Thread(new WriteTask());
        Thread thread2 = new Thread(new ReadTask());
        thread1.start();
        thread2.start();

        // 等待两个线程执行完毕
        thread1.join();
        thread2.join();

        // 打印最终的Map内容
        System.out.println("Final Map:");
        for (Integer key : map.keySet()) {
            System.out.println("Key: " + key + ", Value: " + map.get(key));
        }
    }

    static class WriteTask implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                map.put(i, "Value " + i);
                System.out.println("Thread 1: Added " + i);
            }
        }
    }

    static class ReadTask implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                if (map.containsKey(i)) {
                    String value = map.get(i);
                    System.out.println("Thread 2: Read " + value);
                }
            }
        }
    }
}