模块 java.base
包 java.util.concurrent

接口 ConcurrentMap<K,V>

类型参数：
K - 此map维护的键类型
V - 映射值的类型
所有父级接口：
Map<K,V>
所有已知的子接口：
ConcurrentNavigableMap<K,V>
所有已知的实现类：
ConcurrentHashMap , ConcurrentSkipListMap
public interface ConcurrentMap<K,V> extends Map <K,V>
A Map 提供线程安全和原子性保证。

为了保持指定的保证，方法的默认实现包括从 Map 继承的 putIfAbsent(K, V) 必须被这个接口的实现覆盖。同样，方法 Map.keySet() 、 Map.values() 和 Map.entrySet() 返回的集合的实现必须在必要时覆盖 removeIf 等方法以保持原子性保证。

内存一致性影响：与其他并发集合一样，在将对象作为键或值放入 ConcurrentMap 之前线程中的操作 发生在之前 在另一个线程中从 ConcurrentMap 访问或删除该对象之后的操作。

此接口是 Java 集合框架 的成员。

自从：
1.5

  • 内部类总结

    在接口 java.util.Map 中声明的嵌套类/接口

    Map.Entry<K,V>

  • 方法总结

    修饰符和类型
    方法
    描述
    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 ），则尝试使用给定的映射函数计算其值并将其输入此map，除非 null 。
    default V
    computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
    如果指定键的值存在且非空，则尝试在给定键及其当前映射值的情况下计算新映射。
    default void
    forEach(BiConsumer<? super K,? super V> action)
    对此map中的每个条目执行给定的操作，直到处理完所有条目或操作引发异常。
    default V
    getOrDefault(Object key, V defaultValue)
    返回指定键映射到的值，如果此map不包含键的映射，则返回 defaultValue。
    default V
    merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
    如果指定的键尚未与值关联或与 null 关联，则将其与给定的非 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)
    将每个条目的值替换为对该条目调用给定函数的结果，直到处理完所有条目或函数抛出异常。

    在接口 java.util.Map 中声明的方法

    clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, values

  • 方法详情

    • getOrDefault

      default V  getOrDefault(Object  key, V  defaultValue)
      返回指定键映射到的值，如果此map不包含键的映射，则返回 defaultValue。
      指定者：
      getOrDefault 在接口 Map<K,V> 中
      实现注意事项：
      此实现假定 ConcurrentMap 不能包含空值，并且 get() 明确返回空值意味着键不存在。支持空值的实现 must 覆盖这个默认实现。
      参数：
      key - 要返回其关联值的键
      defaultValue - 键的默认映射
      返回：
      指定键映射到的值，或者 defaultValue 如果此map不包含键的映射
      抛出：
      ClassCastException - 如果键的类型不适合此map (optional)
      NullPointerException - 如果指定键为空且此map不允许空键 (optional)
      自从：
      1.8

    • forEach

      default void forEach(BiConsumer <? super K ,? super V > action)
      对此map中的每个条目执行给定的操作，直到处理完所有条目或操作引发异常。除非实现类另有指定，否则操作将按照条目集迭代的顺序执行（如果指定了迭代顺序）。操作抛出的异常将传递给调用者。
      指定者：
      forEach 在接口 Map<K,V> 中
      实现要求：
      对于这个 map，默认实现等效于： 
       
 for (Map.Entry<K,V> entry : map.entrySet()) {
  action.accept(entry.getKey(), entry.getValue());
 }
      实现注意事项：
      默认实现假设 getKey() 或 getValue() 抛出的 IllegalStateException 表示该条目已被删除且无法处理。后续条目的操作继续进行。
      参数：
      action - 每个条目要执行的操作
      抛出：
      NullPointerException - 如果指定的操作为空
      自从：
      1.8

    • putIfAbsent

      V  putIfAbsent(K  key, V  value)
      如果指定的键尚未与值关联，则将其与给定值关联。这相当于，对于这个 map : 
       
 if (!map.containsKey(key))
  return map.put(key, value);
 else
  return map.get(key);
      除了动作是原子执行的。
      指定者：
      putIfAbsent 在接口 Map<K,V> 中
      实现注意事项：
      此实现有意重新抽象了 Map 中提供的不适当默认值。
      参数：
      key - 与指定值关联的键
      value - 与指定键关联的值
      返回：
      与指定键关联的先前值，或者 null 如果键没有映射。 （如果实现支持空值，则 null 返回还可以指示之前将 null 与键相关联的映射。）
      抛出：
      UnsupportedOperationException - 如果此map不支持 put 操作
      ClassCastException - 如果指定键或值的类阻止它存储在此map中
      NullPointerException - 如果指定的键或值为空，并且此map不允许空键或值
      IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此map中

    • remove

      boolean remove(Object  key, Object  value)
      仅当当前映射到给定值时才删除键的条目。这相当于，对于这个 map : 
       
 if (map.containsKey(key)
   && Objects.equals(map.get(key), value)) {
  map.remove(key);
  return true;
 } else {
  return false;
 }
      除了动作是原子执行的。
      指定者：
      remove 在接口 Map<K,V> 中
      实现注意事项：
      此实现有意重新抽象了 Map 中提供的不适当默认值。
      参数：
      key - 与指定值关联的键
      value - 预期与指定键关联的值
      返回：
      true 如果值被删除
      抛出：
      UnsupportedOperationException - 如果此map不支持 remove 操作
      ClassCastException - 如果键或值的类型不适合此map (optional)
      NullPointerException - 如果指定的键或值为空，并且此map不允许空键或值 (optional)

    • replace

      boolean replace(K  key, V  oldValue, V  newValue)
      仅当当前映射到给定值时才替换键的条目。对于这个 map : 
       
 if (map.containsKey(key)
   && Objects.equals(map.get(key), oldValue)) {
  map.put(key, newValue);
  return true;
 } else {
  return false;
 }
      这等同于该操作是原子执行的。
      指定者：
      replace 在接口 Map<K,V> 中
      实现注意事项：
      此实现有意重新抽象了 Map 中提供的不适当默认值。
      参数：
      key - 与指定值关联的键
      oldValue - 预期与指定键关联的值
      newValue - 与指定键关联的值
      返回：
      true 如果值被替换
      抛出：
      UnsupportedOperationException - 如果此map不支持 put 操作
      ClassCastException - 如果指定键或值的类阻止它存储在此map中
      NullPointerException - 如果指定的键或值为空，并且此map不允许空键或值
      IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此map中

    • replace

      V  replace(K  key, V  value)
      仅当当前映射到某个值时才替换键的条目。这相当于，对于这个 map : 
       
 if (map.containsKey(key))
  return map.put(key, value);
 else
  return null;
      除了动作是原子执行的。
      指定者：
      replace 在接口 Map<K,V> 中
      实现注意事项：
      此实现有意重新抽象了 Map 中提供的不适当默认值。
      参数：
      key - 与指定值关联的键
      value - 与指定键关联的值
      返回：
      与指定键关联的先前值，或者 null 如果键没有映射。 （如果实现支持空值，则 null 返回还可以指示之前将 null 与键相关联的映射。）
      抛出：
      UnsupportedOperationException - 如果此map不支持 put 操作
      ClassCastException - 如果指定键或值的类阻止它存储在此map中
      NullPointerException - 如果指定的键或值为空，并且此map不允许空键或值
      IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此map中

    • replaceAll

      default void replaceAll(BiFunction <? super K ,? super V ,? extends V > function)
      将每个条目的值替换为对该条目调用给定函数的结果，直到处理完所有条目或函数抛出异常。函数抛出的异常被转发给调用者。
      指定者：
      replaceAll 在接口 Map<K,V> 中
      实现要求：

      对于这个 map，默认实现等效于：

       
 for (Map.Entry<K,V> entry : map.entrySet()) {
  K k;
  V v;
  do {
   k = entry.getKey();
   v = entry.getValue();
  } while (!map.replace(k, v, function.apply(k, v)));
 }
      默认实现可能会在多个线程尝试更新时重试这些步骤，包括可能为给定键重复调用该函数。

      此实现假定 ConcurrentMap 不能包含空值，并且 get() 明确返回空值意味着键不存在。支持空值的实现 must 覆盖这个默认实现。

      参数：
      function - 应用于每个条目的函数
      抛出：
      UnsupportedOperationException - 如果此map的条目集迭代器不支持 set 操作。
      NullPointerException - 如果指定的函数为空，或者替换值为空并且此map不允许空值 (optional)
      ClassCastException - 如果替换值的类阻止它存储在此map中 (optional)
      IllegalArgumentException - 如果替换值的某些属性阻止它存储在此map中 (optional)
      自从：
      1.8

    • computeIfAbsent

      default V  computeIfAbsent(K  key, Function <? super K ,? extends V > mappingFunction)
      如果指定的键尚未与值关联（或映射到 null ），则尝试使用给定的映射函数计算其值并将其输入此map，除非 null 。

      如果map函数返回 null ，则不记录任何映射。如果map函数本身抛出（未经检查的）异常，则重新抛出异常，并且不记录任何映射。最常见的用法是构造一个新对象作为初始映射值或记忆结果，如下所示：

       
 map.computeIfAbsent(key, k -> new Value(f(k)));

      或者实现多值映射 Map<K,Collection<V>> ，支持每个键多个值：

       
 map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);

      映射函数不应在计算期间修改此map。

      指定者：
      computeIfAbsent 在接口 Map<K,V> 中
      实现要求：
      默认实现等效于此 map 的以下步骤： 
       
 V oldValue, newValue;
 return ((oldValue = map.get(key)) == null
     && (newValue = mappingFunction.apply(key)) != null
     && (oldValue = map.putIfAbsent(key, newValue)) == null)
  ? newValue
  : oldValue;

      此实现假定 ConcurrentMap 不能包含空值，并且 get() 明确返回空值意味着键不存在。支持空值的实现 must 覆盖这个默认实现。

      参数：
      key - 与指定值关联的键
      mappingFunction - 计算值的映射函数
      返回：
      与指定键关联的当前（现有或计算）值，如果计算值为 null，则为 null
      抛出：
      UnsupportedOperationException - 如果此map不支持 put 操作 (optional )
      ClassCastException - 如果指定键或值的类阻止它存储在此map中 (optional)
      NullPointerException - 如果指定键为空且此map不支持空键，或者 mappingFunction 为空
      IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此map中 (optional)
      自从：
      1.8

    • computeIfPresent

      default V  computeIfPresent(K  key, BiFunction <? super K ,? super V ,? extends V > remappingFunction)
      如果指定键的值存在且非空，则尝试在给定键及其当前映射值的情况下计算新映射。

      如果重映射函数返回 null ，则删除映射。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并且当前映射保持不变。

      重新映射函数不应在计算期间修改此map。

      指定者：
      computeIfPresent 在接口 Map<K,V> 中
      实现要求：
      默认实现相当于为此执行以下步骤 map ： 
       
 for (V oldValue; (oldValue = map.get(key)) != null; ) {
  V newValue = remappingFunction.apply(key, oldValue);
  if ((newValue == null)
    ? map.remove(key, oldValue)
    : map.replace(key, oldValue, newValue))
   return newValue;
 }
 return null;
      当多个线程尝试更新时，可能会多次调用map操作和重映射函数。

      此实现假定 ConcurrentMap 不能包含空值，并且 get() 明确返回空值意味着键不存在。支持空值的实现 must 覆盖这个默认实现。

      参数：
      key - 与指定值关联的键
      remappingFunction - 计算值的重映射函数
      返回：
      与指定键关联的新值，如果没有则为 null
      抛出：
      UnsupportedOperationException - 如果此map不支持 put 操作 (optional )
      ClassCastException - 如果指定键或值的类阻止它存储在此map中 (optional)
      NullPointerException - 如果指定键为空且此map不支持空键，或者 remappingFunction 为空
      IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此map中 (optional)
      自从：
      1.8

    • compute

      default V  compute(K  key, BiFunction <? super K ,? super V ,? extends V > remappingFunction)
      尝试计算指定键及其当前映射值的映射（如果没有当前映射，则为 null）。例如，要创建 String msg 或将其附加到值映射： 
       
 map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))
      （方法 merge() 通常更易于用于此类目的。）

      如果重新映射函数返回 null ，则映射将被删除（或者如果最初不存在则保持不存在）。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并且当前映射保持不变。

      重新映射函数不应在计算期间修改此map。

      指定者：
      compute 在接口 Map<K,V> 中
      实现要求：
      默认实现相当于为此执行以下步骤 map ： 
       
 for (;;) {
  V oldValue = map.get(key);
  V newValue = remappingFunction.apply(key, oldValue);
  if (newValue != null) {
   if ((oldValue != null)
    ? map.replace(key, oldValue, newValue)
    : map.putIfAbsent(key, newValue) == null)
    return newValue;
  } else if (oldValue == null || map.remove(key, oldValue)) {
   return null;
  }
 }
      当多个线程尝试更新时，可能会多次调用map操作和重映射函数。

      此实现假定 ConcurrentMap 不能包含空值，并且 get() 明确返回空值意味着键不存在。支持空值的实现 must 覆盖这个默认实现。

      参数：
      key - 与指定值关联的键
      remappingFunction - 计算值的重映射函数
      返回：
      与指定键关联的新值，如果没有则为 null
      抛出：
      UnsupportedOperationException - 如果此map不支持 put 操作 (optional )
      ClassCastException - 如果指定键或值的类阻止它存储在此map中 (optional)
      NullPointerException - 如果指定键为空且此map不支持空键，或者 remappingFunction 为空
      IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此map中 (optional)
      自从：
      1.8

    • merge

      default V  merge(K  key, V  value, BiFunction <? super V ,? super V ,? extends V > remappingFunction)
      如果指定的键尚未与值关联或与 null 关联，则将其与给定的非 null 值关联。否则，将关联值替换为给定重映射函数的结果，或者如果结果为 null 则移除。当组合一个键的多个映射值时，此方法可能有用。例如，要创建 String msg 或将其附加到值映射： 
       
 map.merge(key, msg, String::concat)

      如果重映射函数返回 null ，则删除映射。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并且当前映射保持不变。

      重新映射函数不应在计算期间修改此map。

      指定者：
      merge 在接口 Map<K,V> 中
      实现要求：
      默认实现相当于为此执行以下步骤 map ： 
       
 for (;;) {
  V oldValue = map.get(key);
  if (oldValue != null) {
   V newValue = remappingFunction.apply(oldValue, value);
   if (newValue != null) {
    if (map.replace(key, oldValue, newValue))
     return newValue;
   } else if (map.remove(key, oldValue)) {
    return null;
   }
  } else if (map.putIfAbsent(key, value) == null) {
   return value;
  }
 }
      当多个线程尝试更新时，可能会多次调用map操作和重映射函数。

      此实现假定 ConcurrentMap 不能包含空值，并且 get() 明确返回空值意味着键不存在。支持空值的实现 must 覆盖这个默认实现。

      参数：
      key - 与结果值关联的键
      value - 要与键关联的现有值合并的非空值，或者，如果没有现有值或空值与键关联，则与键关联
      remappingFunction - 重新映射函数以重新计算值（如果存在）
      返回：
      与指定键关联的新值，如果没有值与该键关联，则返回 null
      抛出：
      UnsupportedOperationException - 如果此map不支持 put 操作 (optional )
      ClassCastException - 如果指定键或值的类阻止它存储在此map中 (optional)
      NullPointerException - 如果指定键为空且此map不支持空键或值或 remappingFunction 为空
      IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此map中 (optional)
      自从：
      1.8