Java基础：为什么hashmap是线程不安全的？

谁借莪１个温暖的怀抱￠ 2023-10-12 09:58 26阅读 0赞

## 原因 ##

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

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

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

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

1.  使用同步机制：可以使用线程安全的 Map 实现，如 ConcurrentHashMap，或者通过在访问 HashMap 时使用 synchronized 或其他锁机制来确保同一时间只有一个线程能够修改 HashMap。
2.  使用并发容器：可以使用线程安全的并发容器，如 ConcurrentMap 或 CopyOnWriteMap，它们提供了并发访问的能力，适用于读多写少的场景。
3.  使用线程封闭：可以将 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);
                    }
                }
            }
        }
    }

在修正后的代码中，我们通过调用 `Thread.join()` 方法，使得主线程等待 `Thread 1` 和 `Thread 2` 完成执行后再继续执行。然后，我们打印出最终的 `HashMap` 内容以验证线程安全性。

尽管代码中没有使用同步机制或其他线程安全的容器来确保线程安全性，但由于此示例中的读写操作相对简单，可能会在某些情况下产生正确的输出。但是，这并不代表 `HashMap` 是线程安全的。在更复杂的并发场景中，仍然存在竞态条件和数据不一致的风险。

为了在多线程环境中安全地使用 Map，推荐使用线程安全的 Map 实现，如 `ConcurrentHashMap`，或者采用适当的同步机制来确保线程安全性。