HashMap和Hashtable怎么选？Java哈希表使用技巧

在Java集合框架中，`HashMap`与`Hashtable`的选择至关重要。多数情况下，应首选`HashMap`，因其在单线程环境下的卓越性能和现代化的设计。`Hashtable`因其所有方法同步，导致多线程环境性能低下，且不支持null键和null值，已逐渐被淘汰。`HashMap`则允许一个null键和多个null值，提供更大灵活性。对于多线程环境，`ConcurrentHashMap`凭借其CAS操作和细粒度锁机制，成为首选，显著提升并发性能。实际开发中，单线程选用`HashMap`，高并发选用`ConcurrentHashMap`，`Hashtable`基本无需考虑。理解它们各自的特性和适用场景，是写出高效、健壮Java代码的关键。

绝大多数情况下应选择HashMap，因为它在单线程环境下性能更优且设计更现代；2. Hashtable所有方法均同步，导致多线程下性能差，且不支持null键和null值，已被视为过时；3. HashMap允许一个null键和多个null值，提供了更大的灵活性；4. 在多线程环境中，应优先使用ConcurrentHashMap而非Hashtable，因其采用CAS和细粒度锁机制，能显著提升并发性能；5. ConcurrentHashMap通过无锁读取和桶级加锁实现高效并发，是高并发场景下的首选线程安全Map实现；6. Hashtable继承自古老的Dictionary类，而HashMap实现Map接口，更好地融入现代Java集合框架体系；7. 实际开发中，单线程用HashMap，高并发用ConcurrentHashMap，Hashtable基本无需使用。

在Java集合框架中，选择HashMap还是Hashtable，答案其实很明确：绝大多数情况下，你应该选择HashMap。Hashtable是Java早期API的产物，设计上带有明显的时代烙印，尤其是在并发处理和性能方面，已经远不如现代的HashMap及其并发变体如ConcurrentHashMap。

解决方案

简单来说，如果你需要一个键值对存储结构，并且不涉及多线程并发写入操作，或者你可以自行处理外部同步，那么HashMap是你的首选。它在单线程环境下的性能表现优异，因为它没有额外的同步开销。

Hashtable之所以现在很少被直接使用，核心原因在于它的所有公共方法都被synchronized关键字修饰，这意味着任何对Hashtable的操作（无论是读还是写）都需要获取锁，这在多线程环境下会造成严重的性能瓶颈。即使是多个线程仅仅进行读取操作，也需要排队等待锁释放，效率非常低下。

此外，HashMap允许键和值都为null，而Hashtable不允许。这是另一个实际使用中需要注意的区别。Hashtable在遇到null键或null值时会抛出NullPointerException。从API设计角度看，HashMap更灵活。

如果你确实需要在多线程环境下使用线程安全的Map，那么现代的选择是ConcurrentHashMap。它通过更精细的锁机制（如分段锁或CAS操作）实现了更高的并发性能，而不是像Hashtable那样简单粗暴地对整个Map加锁。

Java中HashMap和Hashtable在多线程环境下的性能差异与线程安全性考量

谈到多线程，HashMap和Hashtable的差异就变得非常显著。Hashtable的设计初衷就是线程安全的，它的每个公共方法，比如put()、get()、remove()等，都被synchronized关键字修饰了。这意味着在任何时刻，只有一个线程能够访问Hashtable的实例方法。这种“全同步”策略虽然保证了线程安全，但在高并发场景下，性能会急剧下降，因为所有线程都必须等待获取同一个锁。这就好比一个独木桥，一次只能过一个人，即使桥很宽，也只能排队。

// Hashtable的内部方法（简化示意）
public synchronized V put(K key, V value) {
    // ... 内部逻辑 ...
}

public synchronized V get(Object key) {
    // ... 内部逻辑 ...
}

HashMap则完全不同，它从设计之初就没有考虑线程安全。它的方法没有synchronized修饰，所以在多线程环境下，多个线程可以同时对HashMap进行读写操作，这可能导致数据不一致、死循环（在put操作扩容时）等问题。

// HashMap的内部方法（简化示意）
public V put(K key, V value) {
    // ... 内部逻辑 ...
}

public V get(Object key) {
    // ... 内部逻辑 ...
}

在单线程环境中，HashMap因为没有同步开销，性能自然比Hashtable要好。而在多线程环境中，如果确实需要线程安全的Map，我们通常会选择ConcurrentHashMap。ConcurrentHashMap在Java 7及之前版本采用分段锁（Segment）的机制，允许多个线程同时访问不同的段，从而提高并发度。Java 8以后，它改用CAS（Compare-And-Swap）操作和synchronized关键字（针对哈希桶的头部节点）来保证线程安全，进一步优化了性能，避免了整个Map的锁竞争。所以，当你面对并发问题时，ConcurrentHashMap几乎总是优于Hashtable的方案。

理解HashMap与Hashtable的Null键值特性及Java集合框架演进中的定位

关于null键和null值，这是HashMap和Hashtable在使用上一个非常直观的区别。

HashMap允许且仅允许一个null键。这意味着你可以将null作为键存储一个值。同时，HashMap也允许存储多个null值。

HashMap<String, String> hashMap = new HashMap<>();
hashMap.put(null, "Value for null key"); // 允许
hashMap.put("Key1", null);              // 允许
hashMap.put("Key2", null);              // 允许
System.out.println(hashMap.get(null));  // Output: Value for null key

而Hashtable则不然。它不允许任何null键或null值。如果你尝试这样做，它会立即抛出NullPointerException。

Hashtable<String, String> hashtable = new Hashtable<>();
try {
    hashtable.put(null, "Value for null key"); // 抛出 NullPointerException
} catch (NullPointerException e) {
    System.out.println("Hashtable cannot handle null key.");
}
try {
    hashtable.put("Key1", null);              // 抛出 NullPointerException
} catch (NullPointerException e) {
    System.out.println("Hashtable cannot handle null value.");
}

这个差异其实也反映了它们在Java集合框架演进中的不同定位。Hashtable是Java 1.0时期就存在的类，它继承自抽象类Dictionary。Dictionary是一个抽象类，旨在提供键值对映射的基本功能，但它本身并不是Java集合框架（Java 1.2引入）的正式成员。Hashtable作为Dictionary的唯一具体实现，是早期Java提供的一种映射结构。

HashMap则是在Java 1.2版本，随着集合框架的引入而诞生的。它实现了Map接口，并且继承自AbstractMap。Map接口是集合框架的核心接口之一，定义了键值对映射的通用行为。HashMap的设计更符合现代软件开发的理念，更注重性能和灵活性。可以说，HashMap是Hashtable的“升级版”或“替代品”，它在设计上解决了Hashtable的一些局限性，并且更好地融入了整个Java集合框架的体系。从这个角度看，Hashtable更多的是一个历史遗留的API，而HashMap才是当前和未来开发的主流选择。

实际开发中何时选用HashMap或其并发替代品：ConcurrentHashMap详解

在实际的Java开发中，关于HashMap和Hashtable的选择，以及何时引入ConcurrentHashMap，这几乎是一个必考的知识点，也是日常编码中经常需要做出的决策。

选择HashMap的场景：

• 单线程环境： 这是HashMap最典型的应用场景。如果你确定你的Map只会在一个线程中被操作，或者虽然在多线程环境中，但你通过其他外部机制（比如将Map作为局部变量，或者确保所有对Map的操作都在同一个线程中完成）保证了不会出现并发修改，那么HashMap是性能最好的选择。
• 读多写少且外部同步： 即使在多线程环境下，如果你的Map主要是读取操作，写入操作非常少，并且你愿意通过Collections.synchronizedMap(new HashMap<>())来手动提供外部同步（这种方式与Hashtable类似，都是对整个Map加锁，性能瓶颈依然存在，但至少比Hashtable灵活，可以按需同步），HashMap依然可以考虑。不过，这通常不是最优解。

// 典型的HashMap使用
Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 95);
scores.put("Bob", 88);
System.out.println(scores.get("Alice")); // 95

选择ConcurrentHashMap的场景：

• 高并发读写环境： 这是ConcurrentHashMap设计的核心目的。当你需要一个在多线程环境下能够安全、高效地进行读写操作的Map时，ConcurrentHashMap是毫无疑问的首选。它通过精妙的内部机制，允许多个线程同时进行读操作，并且在写操作时也能保持较高的并发度。
• 性能要求高且需要线程安全： 如果你的应用对性能有严格要求，同时又不能牺牲线程安全性，那么ConcurrentHashMap是最佳实践。它避免了Hashtable和Collections.synchronizedMap那种粗粒度的锁机制，显著减少了锁竞争。

ConcurrentHashMap的工作原理（Java 8为例）：

在Java 8中，ConcurrentHashMap放弃了Java 7及以前的分段锁（Segment）机制，转而采用了一种更细粒度的锁策略：CAS（Compare-And-Swap）操作和synchronized关键字。

• 数据结构： 依然是数组加链表/红黑树的结构。
• 插入/更新操作： 当进行put操作时，ConcurrentHashMap会尝试使用CAS操作来更新节点。如果CAS失败（说明有其他线程同时修改了该位置），它会退化到使用synchronized关键字来锁定该哈希桶的头部节点。这意味着只有发生哈希冲突的桶才会被锁住，而不是整个Map，大大提高了并发性。
• 读取操作： 读取操作通常不需要加锁，因为写操作会保证内存可见性（通过volatile或final字段，以及写操作完成后的内存屏障）。这使得读操作可以与写操作并行进行，效率极高。

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ConcurrentMapExample {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Integer> concurrentScores = new ConcurrentHashMap<>();
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 100; i++) {
            final int index = i;
            executor.submit(() -> {
                concurrentScores.put("Student" + index, 60 + index);
                System.out.println("Put: Student" + index + " Score: " + concurrentScores.get("Student" + index));
            });
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
        System.out.println("Final Map Size: " + concurrentScores.size());
    }
}

这个例子展示了ConcurrentHashMap如何在多线程环境下安全地进行写入操作，而不会出现数据不一致的问题。

总结一下，Hashtable作为历史遗留物，在现代Java开发中几乎没有直接使用的必要。HashMap是单线程或外部同步场景的默认选择，而ConcurrentHashMap则是高并发、线程安全场景下的标准答案。理解它们各自的特性和适用场景，是写出高效、健壮Java代码的关键。

终于介绍完啦！小伙伴们，这篇关于《HashMap和Hashtable怎么选？Java哈希表使用技巧》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！