📌  相关文章
📜  Java ConcurrentHashMap

📅  最后修改于: 2020-09-26 14:15:59             🧑  作者: Mango

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

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

它实现了ConcurrentMap接口。

Java ConcurrentHashMap类实现ConcurrentMap接口。

创建一个ConcurrentHashMap

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

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

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

这里，

  • 键 -用于关联地图中每个元素(值)的唯一标识符
  • 值 -地图中与按键相关联的元素

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

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

默认容量和负载系数

无需定义其容量和负载因子就可以创建并发哈希图。例如， 

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

默认情况下，

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

从其他地图创建ConcurrentHashMap

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

import java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        // Creating a hashmap of even numbers
        HashMap evenNumbers = new HashMap<>();
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("HashMap: " + evenNumbers);

        // Creating a concurrent hashmap from other map
        ConcurrentHashMap 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 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 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 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 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 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()方法遍历我们的条目并执行指定的函数。

它包括两个参数。

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

例如， 

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {

        ConcurrentHashMap 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 。这意味着，如果映射包含4个条目，则该操作将并行执行。

forEach()方法的变体

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

2. search()方法

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

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

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

例如， 

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {

        ConcurrentHashMap 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()方法累积(聚集)映射中的每个条目。当我们需要所有条目来执行一项常见任务(例如添加地图的所有值)时，可以使用此方法。

它包括两个参数。

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

例如， 

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {

        ConcurrentHashMap 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() -返回使用指定的reducer 函数收集所有条目的结果
  • reduceKeys() -返回使用指定的reducer 函数收集所有键的结果
  • reduceValues() -返回使用指定的reducer 函数收集所有值的结果

ConcurrentHashMap和HashMap

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

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

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