Java ConcurrentHashMap

在本教程中，我们将通过示例了解 Java ConcurrentHashMap 类及其操作。

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

它实现了 ConcurrentMap 接口。

创建一个 ConcurrentHashMap

为了创建并发 hashmap，我们必须导入 java.util.concurrent.ConcurrentHashMap 先打包。导入包后，下面是我们如何在 Java 中创建并发哈希图。

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

在上面的代码中，我们创建了一个名为 numbers 的并发 hashmap .

在这里，

键 - 用于关联地图中每个元素（值）的唯一标识符
值 - 由地图中的键关联的元素

注意部分 new ConcurrentHashMap<>(8, 0.6) .这里，第一个参数是容量第二个参数是 loadFactor .

容量 - 这张地图的容量是8个。意思是，它可以存储8个条目。
负载系数 - 此地图的负载系数为 0.6。这意味着，每当我们的哈希表填充 60% 时，条目就会被移动到一个新的哈希表，该哈希表的大小是原始哈希表的两倍。

默认容量和负载率

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

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

默认情况下，

地图的容量为 16
负载系数为 0.75

从其他地图创建 ConcurrentHashMap

下面是我们如何创建一个包含其他地图所有元素的并发 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 类提供了允许我们在地图上执行各种操作的方法。

向 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 类提供不同的批量操作，可以安全地应用于并发地图。

1。 forEach() 方法

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

它包括两个参数。

并行度阈值 - 指定在一个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);

        // 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() 方法根据指定的函数搜索地图并返回匹配的条目。

在这里，指定的函数决定了要搜索的条目。

它还包括一个可选参数 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中的操作并行执行。
变压器 - 这将在数据传递给指定函数之前转换数据。

例如，

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 是一个reducer函数。它收集所有值并添加所有值。

reduce() 方法的变体

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

ConcurrentHashMap vs HashMap

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

ConcurrentHashMap 是线程安全的 收藏。也就是说，多个线程可以同时访问和修改它。
ConcurrentHashMap 提供批量操作的方法，如 forEach() , search() 和 reduce() .

为什么选择 ConcurrentHashMap？

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

Java ConcurrentMap 接口 Java 集接口

java