Java中线程安全的Map

救救孩子把

于 2024-08-08 10:02:07 发布

阅读量1.1k

点赞数 16

文章标签： java 安全开发语言

本文链接：https://blog.csdn.net/yuanmomoya/article/details/141019101

版权

在Java中，HashMap是线程不安全的。在多线程环境中，我们需要其它线程安全的Map来进行操作。

1.hashtable

Map<String,Object> hashtable=new Hashtable<String,Object>();

Hashtable 是 Java 中的一个线程安全的键值对数据结构。

以下是 Hashtable 的一些主要特点和用法：

特点：

线程安全：多个线程可以同时访问和操作 Hashtable ，而不需要额外的同步措施。
不允许键或值为 null ：如果尝试插入 null 键或值，会抛出 NullPointerException 。

基本用法

import java.util.Hashtable;

public class HashtableExample {
    public static void main(String[] args) {
        Hashtable<String, Integer> hashtable = new Hashtable<>();

        // 插入元素
        hashtable.put("apple", 5);
        hashtable.put("banana", 3);

        // 获取元素
        int count = hashtable.get("apple");
        System.out.println("Apple count: " + count);

        // 检查是否包含特定键
        boolean containsKey = hashtable.containsKey("orange");
        System.out.println("Contains orange key: " + containsKey);

        // 移除元素
        hashtable.remove("banana");
    }
}

与 HashMap 相比，Hashtable 由于其线程安全的特性，在多线程环境下可以直接使用，但通常在单线程或对并发要求不高的情况下，HashMap 因为性能更好而更常被使用。如果需要线程安全且对性能要求不是特别苛刻，或者不想自己处理同步问题，Hashtable 是一个选择。

2. 使用 `Collections.synchronizedMap`

Collections.synchronizedMap 是 Java 中用于创建线程安全的 Map 的方法。

它接受一个普通的 Map 对象，并返回一个同步包装后的 Map 对象。

以下是一个简单的示例：

Java

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class SynchronizedMapExa {
    public static void main(String[] args) {
        Map<String, String> originalMap = new HashMap<>();
        originalMap.put("key1", "map-value1");
        originalMap.put("key2", "map-value2");
        // 创建同步的 Map
        Map<String, String> synchronizedMap = Collections.synchronizedMap(originalMap);
        // 多线程环境下可以安全地操作这个同步的 Map
    }
}

使用 Collections.synchronizedMap 的优点是可以方便地将现有的非线程安全的 Map 转换为线程安全的。

但需要注意的是，虽然它保证了线程安全，但在并发环境下，由于对整个 Map 对象进行同步，可能会导致性能上的一些开销。如果多个线程只是对 Map 进行读操作，而很少有写操作，可能会有一定的性能瓶颈。

3.ConcurrentHashMap

Map<String,Object> concurrentHashMap=new ConcurrentHashMap<String,Object>();

ConcurrentHashMap 在 JDK 1.7 和 1.8 中的不同：

数据结构：

JDK 1.7 中，ConcurrentHashMap 由 Segment 数组和 HashEntry 数组组成，Segment 继承自 ReentrantLock ，一个 Segment 里包含一个 HashEntry 数组，对每个 Segment 进行加锁来保证线程安全。
JDK 1.8 中，ConcurrentHashMap 采用了数组 + 链表 + 红黑树的数据结构，锁的粒度更细，采用了 CAS 和 synchronized 来保证线程安全。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExam {
    public static void main(String[] args) {
        // JDK 1.8 中的使用
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // 插入元素
        map.put("apple", 5);
        map.put("banana", 3);

        // 获取元素
        int count = map.get("apple");
        System.out.println("Apple count: " + count);

        // 检查是否包含特定键
        boolean containsKey = map.containsKey("orange");
        System.out.println("Contains orange key: " + containsKey);

        // 移除元素
        map.remove("banana");
    }
}

3.ConcurrentSkipListMap

ConcurrentSkipListMap 是 Java 中一个线程安全的有序映射（Sorted Map）实现。

特点：

线程安全：允许多个线程同时进行访问和修改操作，无需额外的同步机制。
基于跳表（Skip List）数据结构：提供了对数级别的查找、插入和删除操作的时间复杂度。
有序性：元素按照自然顺序或者指定的比较器进行排序。

import java.util.Comparator;
import java.util.concurrent.ConcurrentSkipListMap;

public class ConcurrentSkipListMapExample {
    public static void main(String[] args) {
        // 按照自然顺序排序
        ConcurrentSkipListMap<String, Integer> map1 = new ConcurrentSkipListMap<>();
        map1.put("apple", 5);
        map1.put("banana", 3);

        // 按照自定义比较器排序
        Comparator<String> reverseComparator = Comparator.reverseOrder();
        ConcurrentSkipListMap<String, Integer> map2 = new ConcurrentSkipListMap<>(reverseComparator);
        map2.put("apple", 5);
        map2.put("banana", 3);

        // 操作示例
        int value = map1.get("apple");
        System.out.println("Value for 'apple': " + value);
    }
}