Java中，concurrentHashMap和HashTable有什么区别？

胡晗靓

于 2023-06-06 07:33:11 发布

阅读量516

点赞数 4

分类专栏： Java学习文章标签： java 开发语言

本文链接：https://blog.csdn.net/zhang_hao_chao/article/details/131029014

版权

Java学习专栏收录该内容

29 篇文章 3 订阅

订阅专栏

一、什么是concurrentHashMap

二、什么是HashTable

三、concurrentHashMap和HashTable有什么区别

一、什么是concurrentHashMap

ConcurrentHashMap是Java中的一个线程安全的哈希表，它与HashMap类似，但在多线程环境下提供了更好的性能和可靠性。与Hashtable不同，ConcurrentHashMap支持高并发读写操作，并且不会锁定整个哈希表，而只是锁定其中的一部分。

ConcurrentHashMap的实现原理是将整个哈希表划分为多个小的段（Segment），每个段都包含了若干个键值对（Entry）。当多个线程同时访问哈希表时，它们可以同时访问不同的段，从而避免了锁竞争，大大提高了并发度和性能。

ConcurrentHashMap最常用的方法是put()和get()方法，它们与HashMap类似。除此之外，ConcurrentHashMap还提供了一些其他有用的方法，如size()、containsKey()、containsValue()、remove()等。

下面是一个使用ConcurrentHashMap的示例代码：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);

        System.out.println(map.get("A")); // 输出1

        int oldValue = map.replace("B", 4);
        System.out.println(oldValue); // 输出2
        System.out.println(map.get("B")); // 输出4

        boolean exists = map.containsKey("C");
        System.out.println(exists); // 输出true

        int size = map.size();
        System.out.println(size); // 输出3

        map.remove("C");
        exists = map.containsKey("C");
        System.out.println(exists); // 输出false
    }
}

在这个示例中，我们创建了一个ConcurrentHashMap对象，并使用put()方法添加了三个键值对。然后使用get()方法获取"A"对应的值，使用replace()方法替换"B"对应的值，使用containsKey()方法判断"C"是否存在于映射表中，使用size()方法获取映射表的大小，最后使用remove()方法删除"C"键值对。

下面是一个使用ConcurrentHashMap实现线程安全的Map操作的示例代码：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // 线程1向map中添加元素
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                map.put("A" + i, i);
            }
        });

        // 线程2从map中删除元素
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                map.remove("A" + i);
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("map size: " + map.size());
    }
}

在这个示例中，我们创建了一个ConcurrentHashMap对象，并启动了两个线程。线程1向map中添加100000个元素，线程2从map中删除这些元素。最终输出map的大小。

由于ConcurrentHashMap是线程安全的，因此在多线程环境下进行并发的Map操作是安全的。当多个线程同时访问ConcurrentHashMap时，它会自动分割成多个段，每个段上可以同时进行读写操作，不同的段之间没有锁竞争，因此效率比较高。

二、什么是HashTable

Hashtable是Java中的一个散列表实现类，它继承自Dictionary类，并实现了Map接口。Hashtable基于哈希表实现，在插入、查找和删除操作时都具有很高的效率。

Hashtable中的数据存储结构类似于数组，使用键值对来存储数据。每个键值对称为一个Entry对象，其中键和值都必须是对象类型，且键不能为null。Hashtable使用每个键的HashCode值来确定该键对应的存储位置。在不发生碰撞的情况下，Hashtable的插入、查找和删除操作都可以在常数时间内完成。

Hashtable也是一个线程安全的类，在多线程环境下可以保证数据的一致性。但是，由于Hashtable使用同步机制来保证线程安全，因此在性能上略逊于HashMap。

Hashtable提供了一些常用的方法如下：

put(Object key, Object value)：将指定的键值对插入到Hashtable中。
get(Object key)：返回指定键所映射的值，如果不存在则返回null。
remove(Object key)：从Hashtable中删除指定键及其对应的值。
size()：返回Hashtable中键值对的数量。
keys()：返回包含Hashtable中所有键的枚举。
values()：返回包含Hashtable中所有值的枚举。

下面是一个使用Hashtable实现缓存的示例代码：

import java.util.Hashtable;

public class Cache {
    private Hashtable<String, Object> cache;

    public Cache() {
        this.cache = new Hashtable<>();
    }

    public synchronized void put(String key, Object value) {
        cache.put(key, value);
    }

    public synchronized Object get(String key) {
        return cache.get(key);
    }

    public synchronized void remove(String key) {
        cache.remove(key);
    }

    public synchronized int size() {
        return cache.size();
    }
}

这个示例中，我们实现了一个缓存类Cache，它使用Hashtable来存储键值对。在put()、get()、remove()和size()方法中，我们都使用了synchronized关键字来保证线程安全。这样就可以在多线程环境下安全地访问缓存数据了。

HashTable是Java中的一种散列表，它实现了Map接口，并且是线程安全的。Hashtable使用键值对存储数据，在内部使用哈希表来实现快速的访问和操作。

下面是一个使用HashTable的示例代码：

import java.util.Hashtable;

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

        // 添加键值对
        ht.put(1, "A");
        ht.put(2, "B");
        ht.put(3, "C");

        // 获取指定键的值
        String value = ht.get(2);
        System.out.println("键 2 对应的值为：" + value);

        // 删除指定键的值
        ht.remove(3);
        System.out.println("删除键 3 后的哈希表：" + ht);

        // 遍历哈希表
        for (Integer key : ht.keySet()) {
            String val = ht.get(key);
            System.out.println("键 " + key + " 对应的值为：" + val);
        }
    }
}

在这个示例中，我们创建了一个Hashtable对象，添加了三组整型和字符串类型的键值对。然后通过get()方法获取指定键的值，remove()方法删除指定键的值，并且使用keySet()方法遍历哈希表。最终输出结果如下：

键 2 对应的值为：B
删除键 3 后的哈希表：{1=A, 2=B}
键 1 对应的值为：A
键 2 对应的值为：B

可以看出，程序首先输出了键2对应的值，然后删除了键3，并输出了遍历哈希表的结果。

三、concurrentHashMap和HashTable有什么区别

ConcurrentHashMap和Hashtable都是线程安全的哈希表，但在实现和用法上有一些区别：

同步策略：ConcurrentHashMap采用了分段锁（Segment），每个Segment可以看作是一个独立的Hash表，它们之间并没有竞争关系，不同Segment的操作可并发进行。而Hashtable则使用了一把大锁，所有的操作都需要竞争这把锁。
效率：由于ConcurrentHashMap采用了分段锁，多线程并发访问不同Segment中的元素时，可以提高效率。而Hashtable只能通过锁来保证线程安全，在高并发环境下性能较低。
空值：ConcurrentHashMap允许key和value为空，而Hashtable不允许出现空值。
迭代器：ConcurrentHashMap的迭代器是弱一致性的，可能会返回一些过期的数据。而Hashtable的迭代器是强一致性的，它在创建迭代器时复制了整个HashTable，并在迭代时对副本进行操作，因此不存在过期数据。
扩容：ConcurrentHashMap采用了动态扩容机制，当某个Segment中的元素数量达到阈值时，只需要对该Segment进行扩容即可。而Hashtable在扩容时需要将整个HashTable复制到新的内存空间，所以Hashtable的扩容操作比较耗时。

综上所述，如果在高并发环境下要使用哈希表实现线程安全，建议使用ConcurrentHashMap。而Hashtable则多用于Java早期版本中，由于性能和效率限制，已逐渐被淘汰。