Java併發ConcurrentMap接口

java.util.concurrent.ConcurrentMap接口是Map接口的子接口，支持底層Map變量上的原子操作。它具有獲取和設置方法，如在變量上的讀取和寫入。也就是說，一個集合與同一變量上的任何後續讀取相關聯。該接口確保線程安全性和原子性保證。

ConcurrentMap接口中的方法

序號

方法

描述

default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)

嘗試計算指定鍵及其當前映射值的映射(如果沒有當前映射，則爲null)。

default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)

如果指定的鍵尚未與值相關聯(或映射到null)，則嘗試使用給定的映射函數計算其值，並將其輸入到此映射中，除非爲null。

default V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)

如果指定鍵的值存在且非空，則嘗試計算給定鍵及其當前映射值的新映射。

default void forEach(BiConsumer<? super K,? super V> action)

對此映射中的每個條目執行給定的操作，直到所有條目都被處理或操作引發異常。

default V getOrDefault(Object key, V defaultValue)

返回指定鍵映射到的值，如果此映射不包含該鍵的映射，則返回defaultValue。

default V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)

如果指定的鍵尚未與值相關聯或與null相關聯，則將其與給定的非空值相關聯。

V putIfAbsent(K key, V value)

如果指定的鍵尚未與值相關聯，請將其與給定值相關聯。

boolean remove(Object key, Object value)

僅噹噹前映射到給定值時才刪除鍵的條目。

V replace(K key, V value)

僅噹噹前映射到某個值時才替換該項的條目。

boolean replace(K key, V oldValue, V newValue)

僅噹噹前映射到給定值時才替換鍵的條目。

default void replaceAll(BiFunction<? super K,? super V,? extends V> function)

將每個條目的值替換爲對該條目調用給定函數的結果，直到所有條目都被處理或該函數拋出異常。

實例

以下TestThread程序顯示了基於線程的環境中ConcurrentMap接口的使用。

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)

Java併發編程教程

實用類實例

鎖示例

原子變量示例

執行者示例

線程池示例

高級示例

併發集合

ConcurrentMap接口中的方法

實例