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

你的名字 2024-03-16 12:59 17阅读 0赞

**目录**

一、什么是concurrentHashMap

二、什么是HashTable

三、concurrentHashMap和HashTable有什么区别

--------------------

![a87ca87113c24256a449a4e1d2135a1a.png][]

## 一、什么是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"键值对。

![3a9aa48e2e514b319541f6466bf28ee9.png][]

下面是一个使用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关键字来保证线程安全。这样就可以在多线程环境下安全地访问缓存数据了。

![d12448bbe5214790a0334be87a26721b.png][]

**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都是线程安全的哈希表，但在实现和用法上有一些区别**：

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

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

![95b9a0e70b7f4c8fb18a8dd505ce3840.png][]

[a87ca87113c24256a449a4e1d2135a1a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/6bb797aef9c740d7b04bab37b5f931d5.png
[3a9aa48e2e514b319541f6466bf28ee9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/df8d98f0fa1c48baa4ba5948289c890d.png
[d12448bbe5214790a0334be87a26721b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/06d033aaf8ef4caaab22c4ab8ce0e423.png
[95b9a0e70b7f4c8fb18a8dd505ce3840.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/442b840f08f0482f80fa6cca7be50904.png