原文： https://www.programiz.com/java-programming/concurrenthashmap

在本教程中，我们将借助示例学习 Java ConcurrentHashMap类及其操作。

Java 集合框架的ConcurrentHashMap类提供了线程安全的映射。 也就是说，多个线程可以一次访问该映射，而不会影响映射中条目的一致性。

它实现了ConcurrentMap接口。

Java `ConcurrentHashMap` - 图1

创建一个ConcurrentHashMap

为了创建并发的哈希映射，我们必须首先导入java.util.concurrent.ConcurrentHashMap包。 导入包后，就可以在 Java 中创建并发哈希映射。

  1. // ConcurrentHashMap with capacity 8 and load factor 0.6
  2. ConcurrentHashMap<Key, Value> numbers = new ConcurrentHashMap<>(8, 0.6f);

在上面的代码中，我们创建了一个名为number的并发哈希映射。

这里，

  • key - 用于关联映射中每个元素（值）的唯一标识符
  • value - 映射中与按键相关联的元素

注意部分new ConcurrentHashMap<>(8, 0.6)。 在此，第一个参数是capcity，第二个参数是 loadFactor。

  • capcity - 此映射的容量为 8。意味着，它可以存储 8 个条目。
  • loadFactor - 此映射的负载因子为 0.6。 这意味着，只要我们的哈希表填充了 60%，条目就会移到新哈希表中，其大小是原始哈希表的两倍。

默认容量和负载系数

可以在不定义其容量和负载因子的情况下创建并发哈希映射。 例如，

  1. // ConcurrentHashMap with default capacity and load factor
  2. ConcurrentHashMap<Key, Value> numbers1 = new ConcurrentHashMap<>();

默认，

  • 映射的容量将为 16
  • 负载系数将为 0.75

从其他映射创建ConcurrentHashMap

这是我们如何创建包含其他映射的所有元素的并发哈希映射。

  1. import java.util.concurrent.ConcurrentHashMap;
  2. import java.util.HashMap;
  4. class Main {
  5.     public static void main(String[] args) {
  7.         // Creating a hashmap of even numbers
  8.         HashMap<String, Integer> evenNumbers = new HashMap<>();
  9.         evenNumbers.put("Two", 2);
  10.         evenNumbers.put("Four", 4);
  11.         System.out.println("HashMap: " + evenNumbers);
  13.         // Creating a concurrent hashmap from other map
  14.         ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(evenNumbers);
  15.         numbers.put("Three", 3);
  16.         System.out.println("ConcurrentHashMap: " + numbers);
  17.     }
  18. }

输出

  1. HashMap: {Four=4, Two=2}
  2. ConcurrentHashMap: {Four=4, Two=2, Three=3}

ConcurrentHashMap的方法

ConcurrentHashMap类提供允许我们在映射上执行各种操作的方法。

将元素插入ConcurrentHashMap

  • put() - 将指定的键/值映射插入到映射中
  • putAll() - 将指定映射中的所有条目插入此映射中
  • putIfAbsent() - 如果映射中不存在指定的键，则将指定的键/值映射插入到映射中

例如，

  1. import java.util.concurrent.ConcurrentHashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         // Creating ConcurrentHashMap of even numbers
  6.         ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>();
  8.         // Using put()
  9.         evenNumbers.put("Two", 2);
  10.         evenNumbers.put("Four", 4);
  12.         // Using putIfAbsent()
  13.         evenNumbers.putIfAbsent("Six", 6);
  14.         System.out.println("ConcurrentHashMap of even numbers: " + evenNumbers);
  16.         //Creating ConcurrentHashMap of numbers
  17.         ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  18.         numbers.put("One", 1);
  20.         // Using putAll()
  21.         numbers.putAll(evenNumbers);
  22.         System.out.println("ConcurrentHashMap of numbers: " + numbers);
  23.     }
  24. }

输出：

  1. ConcurrentHashMap of even numbers: {Six=6, Four=4, Two=2}
  2. ConcurrentHashMap of numbers: {Six=6, One=1, Four=-4, Two=2}

访问ConcurrentHashMap元素

1.使用entrySet()，keySet()和values()

  • entrySet() - 返回一组所有键/值映射的映射
  • keySet() - 返回映射的所有键的集合
  • values() - 返回一组所有映射值

例如：

  1. import java.util.concurrent.ConcurrentHashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("ConcurrentHashMap: " + numbers);
  12.         // Using entrySet()
  13.         System.out.println("Key/Value mappings: " + numbers.entrySet());
  15.         // Using keySet()
  16.         System.out.println("Keys: " + numbers.keySet());
  18.         // Using values()
  19.         System.out.println("Values: " + numbers.values());
  20.     }
  21. }

输出：

  1. ConcurrentHashMap: {One=1, Two=2, Three=3}
  2. Key/Value mappings: [One=1, Two=2, Three=3]
  3. Keys: [One, Two, Three]
  4. Values: [1, 2, 3]

2.使用get()和getOrDefault()

  • get() - 返回与指定键关联的值。 如果找不到键，则返回null。
  • getOrDefault() - 返回与指定键关联的值。 如果找不到键，则返回指定的默认值。

例如：

  1. import java.util.concurrent.ConcurrentHashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("ConcurrentHashMap: " + numbers);
  12.         // Using get()
  13.         int value1 = numbers.get("Three");
  14.         System.out.println("Using get(): " + value1);
  16.         // Using getOrDefault()
  17.         int value2 = numbers.getOrDefault("Five", 5);
  18.         System.out.println("Using getOrDefault(): " + value2);
  19.     }
  20. }

输出：

  1. ConcurrentHashMap: {One=1, Two=2, Three=3}
  2. Using get(): 3
  3. Using getOrDefault(): 5

删除ConcurrentHashMap元素

  • remove(key) - 返回并从映射中删除与指定键关联的条目
  • remove(key, value) - 仅当指定键映射到指定值并返回布尔值时，才从映射中删除条目

例如：

  1. import java.util.concurrent.ConcurrentHashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("ConcurrentHashMap: " + numbers);
  12.         // remove method with single parameter
  13.         int value = numbers.remove("Two");
  14.         System.out.println("Removed value: " + value);
  16.         // remove method with two parameters
  17.         boolean result = numbers.remove("Three", 3);
  18.         System.out.println("Is the entry {Three=3} removed? " + result);
  20.         System.out.println("Updated ConcurrentHashMap: " + numbers);
  21.     }
  22. }

输出：

  1. ConcurrentHashMap: {One=1, Two=2, Three=3}
  2. Removed value: 2
  3. Is the entry {Three=3} removed? True
  4. Updated ConcurrentHashMap: {One=1}

ConcurrentHashMap批量操作

ConcurrentHashMap类提供了可以安全地应用于并发映射的不同批量操作。

1. forEach()方法

forEach()方法遍历我们的条目并执行指定的函数。

它包括两个参数。

  • parallelismThreshold - 它指定在映射中有多少个元素运算之后并行执行。
  • convertor - 在将数据传递到指定函数之前，它将转换数据。

例如：

  1. import java.util.concurrent.ConcurrentHashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("ConcurrentHashMap: " + numbers);
  12.         // forEach() without transformer function
  13.         numbers.forEach(4, (k, v) -> System.out.println("key: " + k + " value: " + v));
  15.         // forEach() with transformer function
  16.         System.out.print("Values are ");
  17.         numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", "));
  18.     }
  19. }

输出：

  1. ConcurrentHashMap: {One = 1, Two = 2, Three = 3}
  2. key: One value: 1
  3. key: Two value: 2
  4. key: Three value: 3
  5. Values are 1, 2, 3,

在上面的程序中，我们使用了并行阈值 4。 这意味着，如果映射包含 4 个条目，则该操作将并行执行。

forEach()方法的变体

  • forEachEntry() - 为每个条目执行指定的函数
  • forEachKey() - 为每个键执行指定的函数
  • forEachValue() - 为每个值执行指定的函数

2. search()方法

search()方法基于指定的函数搜索映射并返回匹配的条目。

在此，指定的函数确定要搜索的条目。

它还包括一个可选参数parallelThreshold。 并行阈值指定在映射中有多少个元素之后并行执行该操作。

例如：

  1. import java.util.concurrent.ConcurrentHashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("ConcurrentHashMap: " + numbers);
  12.         // Using search()
  13.         String key = numbers.search(4, (k, v) -> {return v == 3 ? k: null;});
  14.         System.out.println("Searched value: " + key);
  16.     }
  17. }

输出：

  1. ConcurrentHashMap: {One=1, Two=2, Three=3}
  2. Searched value: Three

search()方法的变体

  • searchEntries() - 搜索函数应用于键/值映射
  • searchKeys() - 搜索函数仅适用于按键
  • searchValues() - 搜索函数仅应用于值

3. reduce()方法

reduce()方法累积（聚集）映射中的每个条目。 当我们需要所有条目来执行一项共同任务（例如添加映射的所有值）时，可以使用此方法。

它包含两个参数。

  • parallelismThreshold - 它指定在映射了几个元素之后，并行执行映射中的操作。
  • conventor - 在将数据传递到指定函数之前，它将转换数据。

例如：

  1. import java.util.concurrent.ConcurrentHashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("ConcurrentHashMap: " + numbers);
  12.         // Using search()
  13.         int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2);
  14.         System.out.println("Sum of all values: " + sum);
  16.     }
  17. }

输出：

  1. ConcurrentHashMap: {One=1, Two=2, Three=3}
  2. Sum of all values: 6

在上面的程序中，请注意以下语句

  1. numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1+v2);

Here,

  • 4 是并行阈值
  • （k，v）-> v是一种转换器函数。 它将键/值映射仅转换为值。
  • （v1，v2）-> v1 + v2是归约器函数。 它收集所有值并添加所有值。

reduce()方法的变体

  • reduceEntries() - 使用指定的归约器函数返回收集所有条目的结果
  • reduceKeys() - 使用指定的归约器函数返回收集所有键的结果
  • reduceValues() - 使用指定的归约器函数返回收集所有值的结果

ConcurrentHashMap和HashMap

这是ConcurrentHashMap和HashMap之间的一些区别，

  • ConcurrentHashMap是线程安全的集合。 也就是说，多个线程可以同时访问和修改它。
  • ConcurrentHashMap提供用于批量操作的方法，例如forEach()，search()和reduce()。

为什么选择ConcurrentHashMap？

  • ConcurrentHashMap类允许多个线程同时访问其条目。
  • 默认情况下，并发哈希映射分为 16 个段。 这就是为什么允许 16 个线程同时并发修改映射的原因。 但是，任何数量的线程一次都可以访问该映射。
  • 如果指定的键已经存在，则putIfAbsent()方法将不会覆盖映射中的条目。
  • 它自己提供同步。