jdk-sandbox: comparison jdk/src/java.base/share/classes/java/util/concurrent/ConcurrentMap.java

equal deleted inserted replaced

-:376bb53438b7
+:415a5242e046
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
 package java.util.concurrent;
 import java.util.Map;
 import java.util.Objects;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 /**
 * A {@link java.util.Map} providing thread safety and atomicity
 * guarantees.
+*
+* <p>To maintain the specified guarantees, default implementations of
+* methods including {@link #putIfAbsent} inherited from {@link Map}
+* must be overridden by implementations of this interface. Similarly,
+* implementations of the collections returned by methods {@link
+* #keySet}, {@link #values}, and {@link #entrySet} must override
+* methods such as {@code removeIf} when necessary to
+* preserve atomicity guarantees.
 *
 * <p>Memory consistency effects: As with other concurrent
 * collections, actions in a thread prior to placing an object into a
 * {@code ConcurrentMap} as a key or value
 * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
 * @since 1.5
 * @author Doug Lea
 * @param <K> the type of keys maintained by this map
 * @param <V> the type of mapped values
 */
-public interface ConcurrentMap<K, V> extends Map<K, V> {
+public interface ConcurrentMap<K,V> extends Map<K,V> {
 /**
 * {@inheritDoc}
 *
 * @implNote This implementation assumes that the ConcurrentMap cannot
 * {@inheritDoc}
 *
 * @implSpec The default implementation is equivalent to, for this
 * {@code map}:
 * <pre> {@code
-* for ((Map.Entry<K, V> entry : map.entrySet())
+* for (Map.Entry<K,V> entry : map.entrySet()) {
-*     action.accept(entry.getKey(), entry.getValue());
+*   action.accept(entry.getKey(), entry.getValue());
-* }</pre>
+* }}</pre>
 *
 * @implNote The default implementation assumes that
 * {@code IllegalStateException} thrown by {@code getKey()} or
 * {@code getValue()} indicates that the entry has been removed and cannot
 * be processed. Operation continues for subsequent entries.
 * @since 1.8
 */
 @Override
 default void forEach(BiConsumer<? super K, ? super V> action) {
 Objects.requireNonNull(action);
-for (Map.Entry<K, V> entry : entrySet()) {
+for (Map.Entry<K,V> entry : entrySet()) {
 K k;
 V v;
 try {
 k = entry.getKey();
 v = entry.getValue();
-} catch(IllegalStateException ise) {
+} catch (IllegalStateException ise) {
 // this usually means the entry is no longer in the map.
 continue;
 }
 action.accept(k, v);
 }
 }
 /**
 * If the specified key is not already associated
-* with a value, associate it with the given value.
+* with a value, associates it with the given value.
-* This is equivalent to
+* This is equivalent to, for this {@code map}:
-*  <pre> {@code
+* <pre> {@code
 * if (!map.containsKey(key))
 *   return map.put(key, value);
 * else
-*   return map.get(key);
+*   return map.get(key);}</pre>
-* }</pre>
 *
 * except that the action is performed atomically.
 *
 * @implNote This implementation intentionally re-abstracts the
 * inappropriate default provided in {@code Map}.
 * @throws NullPointerException if the specified key or value is null,
 *         and this map does not permit null keys or values
 * @throws IllegalArgumentException if some property of the specified key
 *         or value prevents it from being stored in this map
 */
 V putIfAbsent(K key, V value);
 /**
 * Removes the entry for a key only if currently mapped to a given value.
-* This is equivalent to
+* This is equivalent to, for this {@code map}:
-*  <pre> {@code
+* <pre> {@code
-* if (map.containsKey(key) && Objects.equals(map.get(key), value)) {
+* if (map.containsKey(key)
+*     && Objects.equals(map.get(key), value)) {
 *   map.remove(key);
 *   return true;
-* } else
+* } else {
 *   return false;
-* }</pre>
+* }}</pre>
 *
 * except that the action is performed atomically.
 *
 * @implNote This implementation intentionally re-abstracts the
 * inappropriate default provided in {@code Map}.
 */
 boolean remove(Object key, Object value);
 /**
 * Replaces the entry for a key only if currently mapped to a given value.
-* This is equivalent to
+* This is equivalent to, for this {@code map}:
-*  <pre> {@code
+* <pre> {@code
-* if (map.containsKey(key) && Objects.equals(map.get(key), oldValue)) {
+* if (map.containsKey(key)
+*     && Objects.equals(map.get(key), oldValue)) {
 *   map.put(key, newValue);
 *   return true;
-* } else
+* } else {
 *   return false;
-* }</pre>
+* }}</pre>
 *
 * except that the action is performed atomically.
 *
 * @implNote This implementation intentionally re-abstracts the
 * inappropriate default provided in {@code Map}.
 */
 boolean replace(K key, V oldValue, V newValue);
 /**
 * Replaces the entry for a key only if currently mapped to some value.
-* This is equivalent to
+* This is equivalent to, for this {@code map}:
-*  <pre> {@code
+* <pre> {@code
-* if (map.containsKey(key)) {
+* if (map.containsKey(key))
 *   return map.put(key, value);
-* } else
+* else
-*   return null;
+*   return null;}</pre>
-* }</pre>
 *
 * except that the action is performed atomically.
 *
 * @implNote This implementation intentionally re-abstracts the
 * inappropriate default provided in {@code Map}.
 * {@inheritDoc}
 *
 * @implSpec
 * <p>The default implementation is equivalent to, for this {@code map}:
 * <pre> {@code
-* for ((Map.Entry<K, V> entry : map.entrySet())
+* for (Map.Entry<K,V> entry : map.entrySet()) {
-*     do {
+*   K k;
-*        K k = entry.getKey();
+*   V v;
-*        V v = entry.getValue();
+*   do {
-*     } while(!replace(k, v, function.apply(k, v)));
+*     k = entry.getKey();
-* }</pre>
+*     v = entry.getValue();
+*   } while (!map.replace(k, v, function.apply(k, v)));
+* }}</pre>
 *
 * The default implementation may retry these steps when multiple
 * threads attempt updates including potentially calling the function
 * repeatedly for a given key.
 *
 */
 @Override
 default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
 Objects.requireNonNull(function);
 forEach((k,v) -> {
-while(!replace(k, v, function.apply(k, v))) {
+while (!replace(k, v, function.apply(k, v))) {
 // v changed or k is gone
 if ( (v = get(k)) == null) {
 // k is no longer in the map.
 break;
 }
 * {@code map}, then returning the current value or {@code null} if now
 * absent:
 *
 * <pre> {@code
 * if (map.get(key) == null) {
-*     V newValue = mappingFunction.apply(key);
+*   V newValue = mappingFunction.apply(key);
-*     if (newValue != null)
+*   if (newValue != null)
-*         return map.putIfAbsent(key, newValue);
+*     return map.putIfAbsent(key, newValue);
-* }
+* }}</pre>
-* }</pre>
 *
 * The default implementation may retry these steps when multiple
 * threads attempt updates including potentially calling the mapping
 * function multiple times.
 *
 * {@inheritDoc}
 *
 * @implSpec
 * The default implementation is equivalent to performing the following
 * steps for this {@code map}, then returning the current value or
-* {@code null} if now absent. :
+* {@code null} if now absent:
 *
 * <pre> {@code
 * if (map.get(key) != null) {
-*     V oldValue = map.get(key);
+*   V oldValue = map.get(key);
-*     V newValue = remappingFunction.apply(key, oldValue);
+*   V newValue = remappingFunction.apply(key, oldValue);
-*     if (newValue != null)
+*   if (newValue != null)
-*         map.replace(key, oldValue, newValue);
+*     map.replace(key, oldValue, newValue);
-*     else
+*   else
-*         map.remove(key, oldValue);
+*     map.remove(key, oldValue);
-* }
+* }}</pre>
-* }</pre>
 *
 * The default implementation may retry these steps when multiple threads
 * attempt updates including potentially calling the remapping function
 * multiple times.
 *
 @Override
 default V computeIfPresent(K key,
 BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
 Objects.requireNonNull(remappingFunction);
 V oldValue;
-while((oldValue = get(key)) != null) {
+while ((oldValue = get(key)) != null) {
 V newValue = remappingFunction.apply(key, oldValue);
 if (newValue != null) {
 if (replace(key, oldValue, newValue))
 return newValue;
 } else if (remove(key, oldValue))
 return null;
 }
 return oldValue;
 }
 /**
 *
 * <pre> {@code
 * V oldValue = map.get(key);
 * V newValue = remappingFunction.apply(key, oldValue);
 * if (oldValue != null ) {
-*    if (newValue != null)
+*   if (newValue != null)
-*       map.replace(key, oldValue, newValue);
+*     map.replace(key, oldValue, newValue);
-*    else
+*   else
-*       map.remove(key, oldValue);
+*     map.remove(key, oldValue);
 * } else {
-*    if (newValue != null)
+*   if (newValue != null)
-*       map.putIfAbsent(key, newValue);
+*     map.putIfAbsent(key, newValue);
-*    else
+*   else
-*       return null;
+*     return null;
-* }
+* }}</pre>
-* }</pre>
 *
 * The default implementation may retry these steps when multiple
 * threads attempt updates including potentially calling the remapping
 * function multiple times.
 *
 @Override
 default V compute(K key,
 BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
 Objects.requireNonNull(remappingFunction);
 V oldValue = get(key);
-for(;;) {
+for (;;) {
 V newValue = remappingFunction.apply(key, oldValue);
 if (newValue == null) {
 // delete mapping
 if (oldValue != null || containsKey(key)) {
 // something to remove
 }
 }
 }
 }
 /**
 * {@inheritDoc}
 *
 * @implSpec
 * The default implementation is equivalent to performing the following
 * {@code null} if absent:
 *
 * <pre> {@code
 * V oldValue = map.get(key);
 * V newValue = (oldValue == null) ? value :
-*              remappingFunction.apply(oldValue, value);
+*     remappingFunction.apply(oldValue, value);
 * if (newValue == null)
-*     map.remove(key);
+*   map.remove(key);
 * else
-*     map.put(key, newValue);
+*   map.put(key, newValue);}</pre>
-* }</pre>
 *
 * <p>The default implementation may retry these steps when multiple
 * threads attempt updates including potentially calling the remapping
 * function multiple times.
 *

changeset 30441	415a5242e046
parent 25859	3317bb8137f4
child 32991	b27c76b82713