Java并发ConcurrentMap接口


java.util.concurrent.ConcurrentMap接口是Map接口的子接口,支持底层映射变量的原子操作。它具有读取和写入易失性变量的方法。也就是说,一个集合与之后的任何一个变量之间都有一个前后关系。该接口确保线程安全和原子性保证。

并发映射方法

Sr.No. 方法和描述
1 default V compute(K key, BiFunction remappingFunction) 尝试计算指定键和其当前映射值的映射(如果没有当前映射,则为null)。
2 default V computeIfAbsent(K key, Function mappingFunction) 如果指定的键尚未与值相关联(或映射为空值),则尝试使用给定的映射函数计算其值,并将其输入到此映射中,除非为空。
3 default V computeIfPresent(K key, BiFunction remappingFunction) 如果指定键的值存在且非空,则尝试计算给定键和其当前映射值的新映射。
4 default void forEach(BiConsumer action) 对此映射中的每个条目执行给定操作,直到处理完所有条目或操作抛出异常为止。
5 default V getOrDefault(Object key, V defaultValue) 返回指定键映射到的值;如果此映射不包含键映射,则返回defaultValue。
6 default V merge(K key, V value, BiFunction remappingFunction) 如果指定的键尚未与某个值关联或者与null关联,则将其与给定的非空值相关联。
7 V putIfAbsent(K key, V value) 如果指定的键尚未与某个值关联,请将其与给定值相关联。
8 boolean remove(Object key,Object value) 只有在当前映射到给定值的情况下才删除键的条目。
9 V replace(K key, V value) 仅当当前映射到某个值时才替换密钥的条目。
10 boolean replace(K key, V oldValue, V newValue) 仅当当前映射到给定值时才替换密钥的条目。
11 default void replaceAll(BiFunction function) 用对该条目调用给定函数的结果替换每个条目的值,直到处理完所有条目或者该函数抛出异常。

下面的TestThread程序显示了ConcurrentMap vs HashMap的用法。

import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class TestThread {

   public static void main(final String[] arguments) {
      Map<String,String> map = new ConcurrentHashMap<String, String>();

      map.put("1", "One");
      map.put("2", "Two");
      map.put("3", "Three");
      map.put("5", "Five");
      map.put("6", "Six");

      System.out.println("Initial ConcurrentHashMap: " + map);
      Iterator<String> iterator = map.keySet().iterator();

      try {

         while(iterator.hasNext()) {
            String key = iterator.next();

            if(key.equals("3")) {
               map.put("4", "Four");
            }
         }
      } catch(ConcurrentModificationException cme) {
         cme.printStackTrace();
      }
      System.out.println("ConcurrentHashMap after modification: " + map);

      map = new HashMap<String, String>();

      map.put("1", "One");
      map.put("2", "Two");
      map.put("3", "Three");
      map.put("5", "Five");
      map.put("6", "Six");

      System.out.println("Initial HashMap: " + map);
      iterator = map.keySet().iterator();

      try {

         while(iterator.hasNext()) {
            String key = iterator.next();

            if(key.equals("3")) {
               map.put("4", "Four");
            }
         }
         System.out.println("HashMap after modification: " + map);
      } catch(ConcurrentModificationException cme) {
         cme.printStackTrace();
      }
   }  
}

这将产生以下结果。

输出

Initial ConcurrentHashMap: {1 = One, 2 = Two, 3 = Three, 5 = Five, 6 = Six}
ConcurrentHashMap after modification: {1 = One, 2 = Two, 3 = Three, 4 = Four, 5 = Five, 6 = Six}
Initial HashMap: {1 = One, 2 = Two, 3 = Three, 5 = Five, 6 = Six}
java.util.ConcurrentModificationException
    at java.util.HashMap$HashIterator.nextNode(Unknown Source)
    at java.util.HashMap$KeyIterator.next(Unknown Source)
    at TestThread.main(TestThread.java:48)