上查看所有课程
ConcurrentHashMap类是Java集合框架的一部分，它提供了一个线程安全的Map。这意味着多个线程可以同时访问Map，而不会影响Map中条目的一致性。
它实现了ConcurrentMap接口。
创建ConcurrentHashMap
为了创建concurrent hashmap，我们必须先导入java.util.concurrent.ConcurrentHashMap包。导入包后，我们可以在Java中创建concurrent hashmap。
// ConcurrentHashMap with capacity 8 and load factor 0.6
ConcurrentHashMap<Key, Value> numbers = new ConcurrentHashMap<>(8, 0.6f);在上面的代码中，我们创建了一个名为numbers的concurrent hashmap。
这里，
- Key - 用于将 map 中的每个元素（值）关联起来的唯一标识符
- Value - 由键在 map 中关联的元素
注意new ConcurrentHashMap<>(8, 0.6)这部分。这里的第一个参数是**容量**，第二个参数是**负载因子**。
- 容量 - 此Map的容量为8。这意味着它可以存储8个条目。
- 负载因子 - 此Map的负载因子为0.6。这意味着，每当我们的哈希表被填充60%时，条目就会被移动到一个大小是原始哈希表两倍的新哈希表中。
默认容量和加载因子
也可以不定义容量和负载因子来创建concurrent hashmap。例如：
// ConcurrentHashMap with default capacity and load factor
ConcurrentHashMap<Key, Value> numbers1 = new ConcurrentHashMap<>();默认情况下，
- Map的容量将是16
- 加载因子将为0.75
从其他Map创建ConcurrentHashMap
以下是如何创建包含其他Map所有元素的concurrent hashmap。
import java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;
class Main {
public static void main(String[] args) {
// Creating a hashmap of even numbers
HashMap<String, Integer> evenNumbers = new HashMap<>();
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
System.out.println("HashMap: " + evenNumbers);
// Creating a concurrent hashmap from other map
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(evenNumbers);
numbers.put("Three", 3);
System.out.println("ConcurrentHashMap: " + numbers);
}
}输出
HashMap: {Four=4, Two=2}
ConcurrentHashMap: {Four=4, Two=2, Three=3}
ConcurrentHashMap的方法
ConcurrentHashMap类提供了允许我们对Map执行各种操作的方法。
向ConcurrentHashMap插入元素
put()- 将指定的键/值映射插入到映射中putAll()- 将指定映射中的所有条目插入到此映射中putIfAbsent()- 如果指定键不在映射中，则将指定的键/值映射插入到映射中
例如，
import java.util.concurrent.ConcurrentHashMap;
class Main {
public static void main(String[] args) {
// Creating ConcurrentHashMap of even numbers
ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>();
// Using put()
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
// Using putIfAbsent()
evenNumbers.putIfAbsent("Six", 6);
System.out.println("ConcurrentHashMap of even numbers: " + evenNumbers);
//Creating ConcurrentHashMap of numbers
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
// Using putAll()
numbers.putAll(evenNumbers);
System.out.println("ConcurrentHashMap of numbers: " + numbers);
}
}输出
ConcurrentHashMap of even numbers: {Six=6, Four=4, Two=2}
ConcurrentHashMap of numbers: {Six=6, One=1, Four=-4, Two=2}
访问ConcurrentHashMap元素
1. 使用 entrySet()、keySet() 和 values()
entrySet()- 返回映射中所有键/值映射的集合keySet()- 返回映射中所有键的集合values()- 返回映射中所有值的集合
例如，
import java.util.concurrent.ConcurrentHashMap;
class Main {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("ConcurrentHashMap: " + numbers);
// Using entrySet()
System.out.println("Key/Value mappings: " + numbers.entrySet());
// Using keySet()
System.out.println("Keys: " + numbers.keySet());
// Using values()
System.out.println("Values: " + numbers.values());
}
}输出
ConcurrentHashMap: {One=1, Two=2, Three=3}
Key/Value mappings: [One=1, Two=2, Three=3]
Keys: [One, Two, Three]
Values: [1, 2, 3]
2. 使用 get() 和 getOrDefault()
get()- 返回与指定键关联的值。如果找不到键，则返回null。getOrDefault()- 返回与指定键关联的值。如果找不到键，则返回指定的默认值。
例如，
import java.util.concurrent.ConcurrentHashMap;
class Main {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("ConcurrentHashMap: " + numbers);
// Using get()
int value1 = numbers.get("Three");
System.out.println("Using get(): " + value1);
// Using getOrDefault()
int value2 = numbers.getOrDefault("Five", 5);
System.out.println("Using getOrDefault(): " + value2);
}
}输出
ConcurrentHashMap: {One=1, Two=2, Three=3}
Using get(): 3
Using getOrDefault(): 5
删除ConcurrentHashMap元素
remove(key)- 返回并从映射中移除与指定键关联的条目remove(key, value)- 仅当指定键映射到指定值时才从映射中移除该条目，并返回一个布尔值
例如，
import java.util.concurrent.ConcurrentHashMap;
class Main {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("ConcurrentHashMap: " + numbers);
// remove method with single parameter
int value = numbers.remove("Two");
System.out.println("Removed value: " + value);
// remove method with two parameters
boolean result = numbers.remove("Three", 3);
System.out.println("Is the entry {Three=3} removed? " + result);
System.out.println("Updated ConcurrentHashMap: " + numbers);
}
}输出
ConcurrentHashMap: {One=1, Two=2, Three=3}
Removed value: 2
Is the entry {Three=3} removed? True
Updated ConcurrentHashMap: {One=1}
批量ConcurrentHashMap操作
ConcurrentHashMap类提供了可以安全应用于并发Map的各种批量操作。
1. forEach() 方法
forEach()方法会迭代我们的条目并执行指定的函数。
它包含两个参数。
- parallelismThreshold - 它指定在Map中有多少个元素后，操作将并行执行。
- transformer - 这将在数据传递给指定函数之前转换数据。
例如，
import java.util.concurrent.ConcurrentHashMap;
class Main {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("ConcurrentHashMap: " + numbers);
// forEach() without transformer function
numbers.forEach(4, (k, v) -> System.out.println("key: " + k + " value: " + v));
// forEach() with transformer function
System.out.print("Values are ");
numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", "));
}
}输出
ConcurrentHashMap: {One = 1, Two = 2, Three = 3}
key: One value: 1
key: Two value: 2
key: Three value: 3
Values are 1, 2, 3,
在上面的程序中，我们使用了并行阈值**4**。这意味着如果Map包含4个条目，操作将并行执行。
forEach() 方法的变体
forEachEntry()- 对每个条目执行指定函数forEachKey()- 对每个键执行指定函数forEachValue()- 对每个值执行指定函数
2. search() 方法
search()方法根据指定的函数搜索Map并返回匹配的条目。
在这里，指定的函数决定了要搜索哪个条目。
它还包含一个可选参数parallelThreshold。并行阈值指定在Map中有多少个元素后，操作将并行执行。
例如，
import java.util.concurrent.ConcurrentHashMap;
class Main {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("ConcurrentHashMap: " + numbers);
// Using search()
String key = numbers.search(4, (k, v) -> {return v == 3 ? k: null;});
System.out.println("Searched value: " + key);
}
}输出
ConcurrentHashMap: {One=1, Two=2, Three=3}
Searched value: Three
search() 方法的变体
searchEntries()- 搜索函数应用于键/值映射searchKeys()- 搜索函数仅应用于键searchValues()- 搜索函数仅应用于值
3. reduce() 方法
reduce()方法会累积（汇集）Map中的每个条目。当我们需要所有条目来执行一个共同的任务时，例如将Map中的所有值相加，就可以使用它。
它包含两个参数。
- parallelismThreshold - 它指定在Map中有多少个元素后，操作将并行执行。
- transformer - 这将在数据传递给指定函数之前转换数据。
例如，
import java.util.concurrent.ConcurrentHashMap;
class Main {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("ConcurrentHashMap: " + numbers);
// Using search()
int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2);
System.out.println("Sum of all values: " + sum);
}
}输出
ConcurrentHashMap: {One=1, Two=2, Three=3}
Sum of all values: 6
在上面的程序中，注意语句
numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1+v2);这里，
- 4是并行阈值
- (k, v) -> v 是一个转换函数。它只将键/值映射转换为值。
- (v1, v2) -> v1+v2 是一个归约函数。它将所有值汇集在一起并相加。
reduce() 方法的变体
reduceEntries()- 使用指定的归约函数返回汇集所有条目的结果reduceKeys()- 使用指定的归约函数返回汇集所有键的结果reduceValues()- 使用指定的归约函数返回汇集所有值的结果
ConcurrentHashMap 与 HashMap 对比
以下是ConcurrentHashMap与HashMap之间的一些区别：
ConcurrentHashMap是一个**线程安全**的集合。也就是说，多个线程可以同时访问和修改它。ConcurrentHashMap提供了批量操作的方法，如forEach()、search()和reduce()。
为什么使用ConcurrentHashMap？
ConcurrentHashMap类允许多个线程同时访问其条目。- 默认情况下，concurrent hashmap被分成**16个段**。这就是为什么允许16个线程同时修改Map的原因。然而，任何数量的线程都可以同时访问Map。
- 如果Map中已存在指定的键，
putIfAbsent()方法将不会覆盖该条目。 - 它提供了自己的同步机制。
另请阅读