자바 동시성-ConcurrentMap 인터페이스

java.util.concurrent.ConcurrentMap 인터페이스는 Map 인터페이스의 하위 인터페이스이며 기본 맵 변수에 대한 원자 연산을 지원합니다. 휘발성 변수에 대한 읽기 및 쓰기처럼 작동하는 get 및 set 메서드가 있습니다. 즉, 세트는 동일한 변수에 대한 후속 get과 사전 발생 관계를 갖습니다. 이 인터페이스는 스레드 안전성과 원 자성 보장을 보장합니다.

ConcurrentMap 메서드

Sr. 아니.	방법 및 설명
1	default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) 지정된 키 및 현재 매핑 된 값 (또는 현재 매핑이없는 경우 null)에 대한 매핑 계산을 시도합니다.
2	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) 지정된 키의 값이 있고 null이 아닌 경우 키와 현재 매핑 된 값이 주어지면 새 매핑을 계산합니다.
4	default void forEach(BiConsumer<? super K,? super V> action) 모든 항목이 처리되거나 작업에서 예외가 발생할 때까지이 맵의 각 항목에 대해 지정된 작업을 수행합니다.
5	default V getOrDefault(Object key, V defaultValue) 지정된 키가 매핑되는 값을 반환하거나이 맵에 키에 대한 매핑이없는 경우 defaultValue를 반환합니다.
6	default V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) 지정된 키가 아직 값과 연결되어 있지 않거나 null과 연결되어있는 경우 해당 키를 지정된 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<? super K,? super V,? extends V> function) 모든 항목이 처리되거나 함수에서 예외가 발생할 때까지 각 항목의 값을 해당 항목에 대해 지정된 함수를 호출 한 결과로 바꿉니다.

예

다음 TestThread 프로그램은 ConcurrentMap 대 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)