freqs}, you
+ * can use {@code freqs.computeIfAbsent(k -> new
+ * LongAdder()).increment();}
+ *
* This class and its views and iterators implement all of the
* optional methods of the {@link Map} and {@link Iterator}
* interfaces.
@@ -92,15 +104,111 @@ import java.io.Serializable;
*
Like {@link Hashtable} but unlike {@link HashMap}, this class
* does not allow {@code null} to be used as a key or value.
*
+ *
ConcurrentHashMapV8s support parallel operations using the {@link
+ * ForkJoinPool#commonPool}. (Task that may be used in other contexts
+ * are available in class {@link ForkJoinTasks}). These operations are
+ * designed to be safely, and often sensibly, applied even with maps
+ * that are being concurrently updated by other threads; for example,
+ * when computing a snapshot summary of the values in a shared
+ * registry. There are three kinds of operation, each with four
+ * forms, accepting functions with Keys, Values, Entries, and (Key,
+ * Value) arguments and/or return values. Because the elements of a
+ * ConcurrentHashMapV8 are not ordered in any particular way, and may be
+ * processed in different orders in different parallel executions, the
+ * correctness of supplied functions should not depend on any
+ * ordering, or on any other objects or values that may transiently
+ * change while computation is in progress; and except for forEach
+ * actions, should ideally be side-effect-free.
+ *
+ *
+ * - forEach: Perform a given action on each element.
+ * A variant form applies a given transformation on each element
+ * before performing the action.
+ *
+ * - search: Return the first available non-null result of
+ * applying a given function on each element; skipping further
+ * search when a result is found.
+ *
+ * - reduce: Accumulate each element. The supplied reduction
+ * function cannot rely on ordering (more formally, it should be
+ * both associative and commutative). There are five variants:
+ *
+ *
+ *
+ * - Plain reductions. (There is not a form of this method for
+ * (key, value) function arguments since there is no corresponding
+ * return type.)
+ *
+ * - Mapped reductions that accumulate the results of a given
+ * function applied to each element.
+ *
+ * - Reductions to scalar doubles, longs, and ints, using a
+ * given basis value.
+ *
+ *
+ *
+ *
+ *
+ * The concurrency properties of bulk operations follow
+ * from those of ConcurrentHashMapV8: Any non-null result returned
+ * from {@code get(key)} and related access methods bears a
+ * happens-before relation with the associated insertion or
+ * update. The result of any bulk operation reflects the
+ * composition of these per-element relations (but is not
+ * necessarily atomic with respect to the map as a whole unless it
+ * is somehow known to be quiescent). Conversely, because keys
+ * and values in the map are never null, null serves as a reliable
+ * atomic indicator of the current lack of any result. To
+ * maintain this property, null serves as an implicit basis for
+ * all non-scalar reduction operations. For the double, long, and
+ * int versions, the basis should be one that, when combined with
+ * any other value, returns that other value (more formally, it
+ * should be the identity element for the reduction). Most common
+ * reductions have these properties; for example, computing a sum
+ * with basis 0 or a minimum with basis MAX_VALUE.
+ *
+ *
Search and transformation functions provided as arguments
+ * should similarly return null to indicate the lack of any result
+ * (in which case it is not used). In the case of mapped
+ * reductions, this also enables transformations to serve as
+ * filters, returning null (or, in the case of primitive
+ * specializations, the identity basis) if the element should not
+ * be combined. You can create compound transformations and
+ * filterings by composing them yourself under this "null means
+ * there is nothing there now" rule before using them in search or
+ * reduce operations.
+ *
+ *
Methods accepting and/or returning Entry arguments maintain
+ * key-value associations. They may be useful for example when
+ * finding the key for the greatest value. Note that "plain" Entry
+ * arguments can be supplied using {@code new
+ * AbstractMap.SimpleEntry(k,v)}.
+ *
+ *
Bulk operations may complete abruptly, throwing an
+ * exception encountered in the application of a supplied
+ * function. Bear in mind when handling such exceptions that other
+ * concurrently executing functions could also have thrown
+ * exceptions, or would have done so if the first exception had
+ * not occurred.
+ *
+ *
Parallel speedups for bulk operations compared to sequential
+ * processing are common but not guaranteed. Operations involving
+ * brief functions on small maps may execute more slowly than
+ * sequential loops if the underlying work to parallelize the
+ * computation is more expensive than the computation
+ * itself. Similarly, parallelization may not lead to much actual
+ * parallelism if all processors are busy performing unrelated tasks.
+ *
+ *
All arguments to all task methods must be non-null.
+ *
+ *
jsr166e note: During transition, this class
+ * uses nested functional interfaces with different names but the
+ * same forms as those expected for JDK8.
+ *
* This class is a member of the
*
* Java Collections Framework.
*
- *
jsr166e note: This class is a candidate replacement for
- * java.util.concurrent.ConcurrentHashMap. During transition, this
- * class declares and uses nested functional interfaces with different
- * names but the same forms as those expected for JDK8.
- *
* @since 1.5
* @author Doug Lea
* @param the type of keys maintained by this map
@@ -179,6 +287,77 @@ public class ConcurrentHashMapV8
Spliterator split();
}
+ /**
+ * A view of a ConcurrentHashMapV8 as a {@link Set} of keys, in
+ * which additions may optionally be enabled by mapping to a
+ * common value. This class cannot be directly instantiated. See
+ * {@link #keySet}, {@link #keySet(Object)}, {@link #newKeySet()},
+ * {@link #newKeySet(int)}.
+ *
+ * The view's {@code iterator} is a "weakly consistent" iterator
+ * that will never throw {@link ConcurrentModificationException},
+ * and guarantees to traverse elements as they existed upon
+ * construction of the iterator, and may (but is not guaranteed to)
+ * reflect any modifications subsequent to construction.
+ */
+ public static class KeySetView extends CHMView implements Set, java.io.Serializable {
+ private static final long serialVersionUID = 7249069246763182397L;
+ private final V value;
+ KeySetView(ConcurrentHashMapV8 map, V value) { // non-public
+ super(map);
+ this.value = value;
+ }
+
+ /**
+ * Returns the map backing this view.
+ *
+ * @return the map backing this view
+ */
+ public ConcurrentHashMapV8 getMap() { return map; }
+
+ /**
+ * Returns the default mapped value for additions,
+ * or {@code null} if additions are not supported.
+ *
+ * @return the default mapped value for additions, or {@code null}
+ * if not supported.
+ */
+ public V getMappedValue() { return value; }
+
+ // implement Set API
+
+ public boolean contains(Object o) { return map.containsKey(o); }
+ public boolean remove(Object o) { return map.remove(o) != null; }
+ public Iterator iterator() { return new KeyIterator(map); }
+ public boolean add(K e) {
+ V v;
+ if ((v = value) == null)
+ throw new UnsupportedOperationException();
+ if (e == null)
+ throw new NullPointerException();
+ return map.internalPutIfAbsent(e, v) == null;
+ }
+ public boolean addAll(Collection c) {
+ boolean added = false;
+ V v;
+ if ((v = value) == null)
+ throw new UnsupportedOperationException();
+ for (K e : c) {
+ if (e == null)
+ throw new NullPointerException();
+ if (map.internalPutIfAbsent(e, v) == null)
+ added = true;
+ }
+ return added;
+ }
+ public boolean equals(Object o) {
+ Set c;
+ return ((o instanceof Set) &&
+ ((c = (Set)o) == this ||
+ (containsAll(c) && c.containsAll(this))));
+ }
+ }
+
/*
* Overview:
*
@@ -461,7 +640,7 @@ public class ConcurrentHashMapV8
private transient volatile int sizeCtl;
// views
- private transient KeySet keySet;
+ private transient KeySetView keySet;
private transient Values values;
private transient EntrySet entrySet;
@@ -2243,7 +2422,8 @@ public class ConcurrentHashMapV8
* change (including to null, indicating deletion), field nextVal
* might not be accurate at point of use, but still maintains the
* weak consistency property of holding a value that was once
- * valid.
+ * valid. To support iterator.remove, the nextKey field is not
+ * updated (nulled out) when the iterator cannot advance.
*
* Internal traversals directly access these fields, as in:
* {@code while (it.advance() != null) { process(it.nextKey); }}
@@ -2280,7 +2460,6 @@ public class ConcurrentHashMapV8
@SuppressWarnings("serial") static class Traverser extends ForkJoinTask {
final ConcurrentHashMapV8 map;
Node next; // the next entry to use
- Node last; // the last entry used
Object nextKey; // cached key field of next
Object nextVal; // cached val field of next
Node[] tab; // current table; updated if resized
@@ -2313,7 +2492,7 @@ public class ConcurrentHashMapV8
* See above for explanation.
*/
final Object advance() {
- Node e = last = next;
+ Node e = next;
Object ev = null;
outer: do {
if (e != null) // advance past used/skipped node
@@ -2347,13 +2526,10 @@ public class ConcurrentHashMapV8
}
public final void remove() {
- if (nextVal == null && last == null)
- advance();
- Node e = last;
- if (e == null)
+ Object k = nextKey;
+ if (k == null && (advance() == null || (k = nextKey) == null))
throw new IllegalStateException();
- last = null;
- map.remove(e.key);
+ map.internalReplace(k, null, null);
}
public final boolean hasNext() {
@@ -2457,6 +2633,32 @@ public class ConcurrentHashMapV8
}
/**
+ * Creates a new {@link Set} backed by a ConcurrentHashMapV8
+ * from the given type to {@code Boolean.TRUE}.
+ *
+ * @return the new set
+ */
+ public static KeySetView newKeySet() {
+ return new KeySetView(new ConcurrentHashMapV8(),
+ Boolean.TRUE);
+ }
+
+ /**
+ * Creates a new {@link Set} backed by a ConcurrentHashMapV8
+ * from the given type to {@code Boolean.TRUE}.
+ *
+ * @param initialCapacity The implementation performs internal
+ * sizing to accommodate this many elements.
+ * @throws IllegalArgumentException if the initial capacity of
+ * elements is negative
+ * @return the new set
+ */
+ public static KeySetView newKeySet(int initialCapacity) {
+ return new KeySetView(new ConcurrentHashMapV8(initialCapacity),
+ Boolean.TRUE);
+ }
+
+ /**
* {@inheritDoc}
*/
public boolean isEmpty() {
@@ -2475,7 +2677,7 @@ public class ConcurrentHashMapV8
/**
* Returns the number of mappings. This method should be used
- * instead of {@link #size} because a ConcurrentHashMap may
+ * instead of {@link #size} because a ConcurrentHashMapV8 may
* contain more mappings than can be represented as an int. The
* value returned is a snapshot; the actual count may differ if
* there are ongoing concurrent insertions or removals.
@@ -2848,22 +3050,31 @@ public class ConcurrentHashMapV8
/**
* Returns a {@link Set} view of the keys contained in this map.
* The set is backed by the map, so changes to the map are
- * reflected in the set, and vice-versa. The set supports element
- * removal, which removes the corresponding mapping from this map,
- * via the {@code Iterator.remove}, {@code Set.remove},
- * {@code removeAll}, {@code retainAll}, and {@code clear}
- * operations. It does not support the {@code add} or
- * {@code addAll} operations.
+ * reflected in the set, and vice-versa.
*
- * The view's {@code iterator} is a "weakly consistent" iterator
- * that will never throw {@link ConcurrentModificationException},
- * and guarantees to traverse elements as they existed upon
- * construction of the iterator, and may (but is not guaranteed to)
- * reflect any modifications subsequent to construction.
+ * @return the set view
+ */
+ public KeySetView keySet() {
+ KeySetView ks = keySet;
+ return (ks != null) ? ks : (keySet = new KeySetView(this, null));
+ }
+
+ /**
+ * Returns a {@link Set} view of the keys in this map, using the
+ * given common mapped value for any additions (i.e., {@link
+ * Collection#add} and {@link Collection#addAll}). This is of
+ * course only appropriate if it is acceptable to use the same
+ * value for all additions from this view.
+ *
+ * @param mappedValue the mapped value to use for any
+ * additions.
+ * @return the set view
+ * @throws NullPointerException if the mappedValue is null
*/
- public Set keySet() {
- KeySet ks = keySet;
- return (ks != null) ? ks : (keySet = new KeySet(this));
+ public KeySetView keySet(V mappedValue) {
+ if (mappedValue == null)
+ throw new NullPointerException();
+ return new KeySetView(this, mappedValue);
}
/**
@@ -3045,7 +3256,7 @@ public class ConcurrentHashMapV8
super(it);
}
public KeyIterator split() {
- if (last != null || (next != null && nextVal == null))
+ if (nextKey != null)
throw new IllegalStateException();
return new KeyIterator(this);
}
@@ -3067,7 +3278,7 @@ public class ConcurrentHashMapV8
super(it);
}
public ValueIterator split() {
- if (last != null || (next != null && nextVal == null))
+ if (nextKey != null)
throw new IllegalStateException();
return new ValueIterator(this);
}
@@ -3090,7 +3301,7 @@ public class ConcurrentHashMapV8
super(it);
}
public EntryIterator split() {
- if (last != null || (next != null && nextVal == null))
+ if (nextKey != null)
throw new IllegalStateException();
return new EntryIterator(this);
}
@@ -3278,30 +3489,6 @@ public class ConcurrentHashMapV8
}
- static final class KeySet extends CHMView implements Set {
- KeySet(ConcurrentHashMapV8 map) {
- super(map);
- }
- public final boolean contains(Object o) { return map.containsKey(o); }
- public final boolean remove(Object o) { return map.remove(o) != null; }
- public final Iterator iterator() {
- return new KeyIterator(map);
- }
- public final boolean add(K e) {
- throw new UnsupportedOperationException();
- }
- public final boolean addAll(Collection c) {
- throw new UnsupportedOperationException();
- }
- public boolean equals(Object o) {
- Set c;
- return ((o instanceof Set) &&
- ((c = (Set)o) == this ||
- (containsAll(c) && c.containsAll(this))));
- }
- }
-
-
static final class Values extends CHMView
implements Collection {
Values(ConcurrentHashMapV8 map) { super(map); }
@@ -3531,645 +3718,503 @@ public class ConcurrentHashMapV8
// -------------------------------------------------------
/**
- * Returns an extended {@link Parallel} view of this map using the
- * given executor for bulk parallel operations.
+ * Performs the given action for each (key, value).
*
- * @param executor the executor
- * @return a parallel view
+ * @param action the action
*/
- public Parallel parallel(ForkJoinPool executor) {
- return new Parallel(executor);
+ public void forEach(BiAction action) {
+ ForkJoinTasks.forEach
+ (this, action).invoke();
}
/**
- * An extended view of a ConcurrentHashMap supporting bulk
- * parallel operations. These operations are designed to be
- * safely, and often sensibly, applied even with maps that are
- * being concurrently updated by other threads; for example, when
- * computing a snapshot summary of the values in a shared
- * registry. There are three kinds of operation, each with four
- * forms, accepting functions with Keys, Values, Entries, and
- * (Key, Value) arguments and/or return values. Because the
- * elements of a ConcurrentHashMap are not ordered in any
- * particular way, and may be processed in different orders in
- * different parallel executions, the correctness of supplied
- * functions should not depend on any ordering, or on any other
- * objects or values that may transiently change while computation
- * is in progress; and except for forEach actions, should ideally
- * be side-effect-free.
- *
- *
- * - forEach: Perform a given action on each element.
- * A variant form applies a given transformation on each element
- * before performing the action.
- *
- * - search: Return the first available non-null result of
- * applying a given function on each element; skipping further
- * search when a result is found.
- *
- * - reduce: Accumulate each element. The supplied reduction
- * function cannot rely on ordering (more formally, it should be
- * both associative and commutative). There are five variants:
- *
- *
- *
- * - Plain reductions. (There is not a form of this method for
- * (key, value) function arguments since there is no corresponding
- * return type.)
- *
- * - Mapped reductions that accumulate the results of a given
- * function applied to each element.
- *
- * - Reductions to scalar doubles, longs, and ints, using a
- * given basis value.
- *
- *
- *
- *
- *
- * The concurrency properties of the bulk operations follow
- * from those of ConcurrentHashMap: Any non-null result returned
- * from {@code get(key)} and related access methods bears a
- * happens-before relation with the associated insertion or
- * update. The result of any bulk operation reflects the
- * composition of these per-element relations (but is not
- * necessarily atomic with respect to the map as a whole unless it
- * is somehow known to be quiescent). Conversely, because keys
- * and values in the map are never null, null serves as a reliable
- * atomic indicator of the current lack of any result. To
- * maintain this property, null serves as an implicit basis for
- * all non-scalar reduction operations. For the double, long, and
- * int versions, the basis should be one that, when combined with
- * any other value, returns that other value (more formally, it
- * should be the identity element for the reduction). Most common
- * reductions have these properties; for example, computing a sum
- * with basis 0 or a minimum with basis MAX_VALUE.
- *
- *
Search and transformation functions provided as arguments
- * should similarly return null to indicate the lack of any result
- * (in which case it is not used). In the case of mapped
- * reductions, this also enables transformations to serve as
- * filters, returning null (or, in the case of primitive
- * specializations, the identity basis) if the element should not
- * be combined. You can create compound transformations and
- * filterings by composing them yourself under this "null means
- * there is nothing there now" rule before using them in search or
- * reduce operations.
- *
- *
Methods accepting and/or returning Entry arguments maintain
- * key-value associations. They may be useful for example when
- * finding the key for the greatest value. Note that "plain" Entry
- * arguments can be supplied using {@code new
- * AbstractMap.SimpleEntry(k,v)}.
- *
- *
Bulk operations may complete abruptly, throwing an
- * exception encountered in the application of a supplied
- * function. Bear in mind when handling such exceptions that other
- * concurrently executing functions could also have thrown
- * exceptions, or would have done so if the first exception had
- * not occurred.
- *
- *
Parallel speedups compared to sequential processing are
- * common but not guaranteed. Operations involving brief
- * functions on small maps may execute more slowly than sequential
- * loops if the underlying work to parallelize the computation is
- * more expensive than the computation itself. Similarly,
- * parallelization may not lead to much actual parallelism if all
- * processors are busy performing unrelated tasks.
- *
- *
All arguments to all task methods must be non-null.
- *
- *
jsr166e note: During transition, this class
- * uses nested functional interfaces with different names but the
- * same forms as those expected for JDK8.
+ * Performs the given action for each non-null transformation
+ * of each (key, value).
+ *
+ * @param transformer a function returning the transformation
+ * for an element, or null of there is no transformation (in
+ * which case the action is not applied).
+ * @param action the action
*/
- public class Parallel {
- final ForkJoinPool fjp;
+ public void forEach(BiFun transformer,
+ Action action) {
+ ForkJoinTasks.forEach
+ (this, transformer, action).invoke();
+ }
- /**
- * Returns an extended view of this map using the given
- * executor for bulk parallel operations.
- *
- * @param executor the executor
- */
- public Parallel(ForkJoinPool executor) {
- this.fjp = executor;
- }
+ /**
+ * Returns a non-null result from applying the given search
+ * function on each (key, value), or null if none. Upon
+ * success, further element processing is suppressed and the
+ * results of any other parallel invocations of the search
+ * function are ignored.
+ *
+ * @param searchFunction a function returning a non-null
+ * result on success, else null
+ * @return a non-null result from applying the given search
+ * function on each (key, value), or null if none
+ */
+ public U search(BiFun searchFunction) {
+ return ForkJoinTasks.search
+ (this, searchFunction).invoke();
+ }
- /**
- * Performs the given action for each (key, value).
- *
- * @param action the action
- */
- public void forEach(BiAction action) {
- fjp.invoke(ForkJoinTasks.forEach
- (ConcurrentHashMapV8.this, action));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all (key, value) pairs using the given reducer to
+ * combine values, or null if none.
+ *
+ * @param transformer a function returning the transformation
+ * for an element, or null of there is no transformation (in
+ * which case it is not combined).
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all (key, value) pairs
+ */
+ public U reduce(BiFun transformer,
+ BiFun reducer) {
+ return ForkJoinTasks.reduce
+ (this, transformer, reducer).invoke();
+ }
- /**
- * Performs the given action for each non-null transformation
- * of each (key, value).
- *
- * @param transformer a function returning the transformation
- * for an element, or null if there is no transformation (in
- * which case the action is not applied)
- * @param action the action
- */
- public void forEach(BiFun transformer,
- Action action) {
- fjp.invoke(ForkJoinTasks.forEach
- (ConcurrentHashMapV8.this, transformer, action));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all (key, value) pairs using the given reducer to
+ * combine values, and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all (key, value) pairs
+ */
+ public double reduceToDouble(ObjectByObjectToDouble transformer,
+ double basis,
+ DoubleByDoubleToDouble reducer) {
+ return ForkJoinTasks.reduceToDouble
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Returns a non-null result from applying the given search
- * function on each (key, value), or null if none. Upon
- * success, further element processing is suppressed and the
- * results of any other parallel invocations of the search
- * function are ignored.
- *
- * @param searchFunction a function returning a non-null
- * result on success, else null
- * @return a non-null result from applying the given search
- * function on each (key, value), or null if none
- */
- public U search(BiFun searchFunction) {
- return fjp.invoke(ForkJoinTasks.search
- (ConcurrentHashMapV8.this, searchFunction));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all (key, value) pairs using the given reducer to
+ * combine values, and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all (key, value) pairs
+ */
+ public long reduceToLong(ObjectByObjectToLong transformer,
+ long basis,
+ LongByLongToLong reducer) {
+ return ForkJoinTasks.reduceToLong
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all (key, value) pairs using the given reducer to
- * combine values, or null if none.
- *
- * @param transformer a function returning the transformation
- * for an element, or null if there is no transformation (in
- * which case it is not combined)
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all (key, value) pairs
- */
- public U reduce(BiFun transformer,
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all (key, value) pairs using the given reducer to
+ * combine values, and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all (key, value) pairs
+ */
+ public int reduceToInt(ObjectByObjectToInt transformer,
+ int basis,
+ IntByIntToInt reducer) {
+ return ForkJoinTasks.reduceToInt
+ (this, transformer, basis, reducer).invoke();
+ }
+
+ /**
+ * Performs the given action for each key.
+ *
+ * @param action the action
+ */
+ public void forEachKey(Action action) {
+ ForkJoinTasks.forEachKey
+ (this, action).invoke();
+ }
+
+ /**
+ * Performs the given action for each non-null transformation
+ * of each key.
+ *
+ * @param transformer a function returning the transformation
+ * for an element, or null of there is no transformation (in
+ * which case the action is not applied).
+ * @param action the action
+ */
+ public void forEachKey(Fun transformer,
+ Action action) {
+ ForkJoinTasks.forEachKey
+ (this, transformer, action).invoke();
+ }
+
+ /**
+ * Returns the result of accumulating all keys using the given
+ * reducer to combine values, or null if none.
+ *
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating all keys using the given
+ * reducer to combine values, or null if none
+ */
+ public K reduceKeys(BiFun reducer) {
+ return ForkJoinTasks.reduceKeys
+ (this, reducer).invoke();
+ }
+
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all keys using the given reducer to combine values, or
+ * null if none.
+ *
+ * @param transformer a function returning the transformation
+ * for an element, or null of there is no transformation (in
+ * which case it is not combined).
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all keys
+ */
+ public U reduceKeys(Fun transformer,
BiFun reducer) {
- return fjp.invoke(ForkJoinTasks.reduce
- (ConcurrentHashMapV8.this, transformer, reducer));
- }
+ return ForkJoinTasks.reduceKeys
+ (this, transformer, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all (key, value) pairs using the given reducer to
- * combine values, and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all (key, value) pairs
- */
- public double reduceToDouble(ObjectByObjectToDouble transformer,
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all keys using the given reducer to combine values, and
+ * the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all keys
+ */
+ public double reduceKeysToDouble(ObjectToDouble transformer,
double basis,
DoubleByDoubleToDouble reducer) {
- return fjp.invoke(ForkJoinTasks.reduceToDouble
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ return ForkJoinTasks.reduceKeysToDouble
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all (key, value) pairs using the given reducer to
- * combine values, and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all (key, value) pairs
- */
- public long reduceToLong(ObjectByObjectToLong transformer,
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all keys using the given reducer to combine values, and
+ * the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all keys
+ */
+ public long reduceKeysToLong(ObjectToLong transformer,
long basis,
LongByLongToLong reducer) {
- return fjp.invoke(ForkJoinTasks.reduceToLong
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ return ForkJoinTasks.reduceKeysToLong
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all (key, value) pairs using the given reducer to
- * combine values, and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all (key, value) pairs
- */
- public int reduceToInt(ObjectByObjectToInt transformer,
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all keys using the given reducer to combine values, and
+ * the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all keys
+ */
+ public int reduceKeysToInt(ObjectToInt transformer,
int basis,
IntByIntToInt reducer) {
- return fjp.invoke(ForkJoinTasks.reduceToInt
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
-
- /**
- * Performs the given action for each key.
- *
- * @param action the action
- */
- public void forEachKey(Action action) {
- fjp.invoke(ForkJoinTasks.forEachKey
- (ConcurrentHashMapV8.this, action));
- }
-
- /**
- * Performs the given action for each non-null transformation
- * of each key.
- *
- * @param transformer a function returning the transformation
- * for an element, or null if there is no transformation (in
- * which case the action is not applied)
- * @param action the action
- */
- public void forEachKey(Fun transformer,
- Action action) {
- fjp.invoke(ForkJoinTasks.forEachKey
- (ConcurrentHashMapV8.this, transformer, action));
- }
-
- /**
- * Returns a non-null result from applying the given search
- * function on each key, or null if none. Upon success,
- * further element processing is suppressed and the results of
- * any other parallel invocations of the search function are
- * ignored.
- *
- * @param searchFunction a function returning a non-null
- * result on success, else null
- * @return a non-null result from applying the given search
- * function on each key, or null if none
- */
- public U searchKeys(Fun searchFunction) {
- return fjp.invoke(ForkJoinTasks.searchKeys
- (ConcurrentHashMapV8.this, searchFunction));
- }
-
- /**
- * Returns the result of accumulating all keys using the given
- * reducer to combine values, or null if none.
- *
- * @param reducer a commutative associative combining function
- * @return the result of accumulating all keys using the given
- * reducer to combine values, or null if none
- */
- public K reduceKeys(BiFun reducer) {
- return fjp.invoke(ForkJoinTasks.reduceKeys
- (ConcurrentHashMapV8.this, reducer));
- }
-
- /**
- * Returns the result of accumulating the given transformation
- * of all keys using the given reducer to combine values, or
- * null if none.
- *
- * @param transformer a function returning the transformation
- * for an element, or null if there is no transformation (in
- * which case it is not combined)
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all keys
- */
- public U reduceKeys(Fun transformer,
- BiFun reducer) {
- return fjp.invoke(ForkJoinTasks.reduceKeys
- (ConcurrentHashMapV8.this, transformer, reducer));
- }
-
- /**
- * Returns the result of accumulating the given transformation
- * of all keys using the given reducer to combine values, and
- * the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all keys
- */
- public double reduceKeysToDouble(ObjectToDouble transformer,
- double basis,
- DoubleByDoubleToDouble reducer) {
- return fjp.invoke(ForkJoinTasks.reduceKeysToDouble
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
-
- /**
- * Returns the result of accumulating the given transformation
- * of all keys using the given reducer to combine values, and
- * the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all keys
- */
- public long reduceKeysToLong(ObjectToLong transformer,
- long basis,
- LongByLongToLong reducer) {
- return fjp.invoke(ForkJoinTasks.reduceKeysToLong
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
-
- /**
- * Returns the result of accumulating the given transformation
- * of all keys using the given reducer to combine values, and
- * the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all keys
- */
- public int reduceKeysToInt(ObjectToInt transformer,
- int basis,
- IntByIntToInt reducer) {
- return fjp.invoke(ForkJoinTasks.reduceKeysToInt
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ return ForkJoinTasks.reduceKeysToInt
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Performs the given action for each value.
- *
- * @param action the action
- */
- public void forEachValue(Action action) {
- fjp.invoke(ForkJoinTasks.forEachValue
- (ConcurrentHashMapV8.this, action));
- }
+ /**
+ * Performs the given action for each value.
+ *
+ * @param action the action
+ */
+ public void forEachValue(Action action) {
+ ForkJoinTasks.forEachValue
+ (this, action).invoke();
+ }
- /**
- * Performs the given action for each non-null transformation
- * of each value.
- *
- * @param transformer a function returning the transformation
- * for an element, or null if there is no transformation (in
- * which case the action is not applied)
- */
- public void forEachValue(Fun transformer,
- Action action) {
- fjp.invoke(ForkJoinTasks.forEachValue
- (ConcurrentHashMapV8.this, transformer, action));
- }
+ /**
+ * Performs the given action for each non-null transformation
+ * of each value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element, or null of there is no transformation (in
+ * which case the action is not applied).
+ */
+ public void forEachValue(Fun transformer,
+ Action action) {
+ ForkJoinTasks.forEachValue
+ (this, transformer, action).invoke();
+ }
- /**
- * Returns a non-null result from applying the given search
- * function on each value, or null if none. Upon success,
- * further element processing is suppressed and the results of
- * any other parallel invocations of the search function are
- * ignored.
- *
- * @param searchFunction a function returning a non-null
- * result on success, else null
- * @return a non-null result from applying the given search
- * function on each value, or null if none
- */
- public U searchValues(Fun searchFunction) {
- return fjp.invoke(ForkJoinTasks.searchValues
- (ConcurrentHashMapV8.this, searchFunction));
- }
+ /**
+ * Returns a non-null result from applying the given search
+ * function on each value, or null if none. Upon success,
+ * further element processing is suppressed and the results of
+ * any other parallel invocations of the search function are
+ * ignored.
+ *
+ * @param searchFunction a function returning a non-null
+ * result on success, else null
+ * @return a non-null result from applying the given search
+ * function on each value, or null if none
+ *
+ */
+ public U searchValues(Fun searchFunction) {
+ return ForkJoinTasks.searchValues
+ (this, searchFunction).invoke();
+ }
- /**
- * Returns the result of accumulating all values using the
- * given reducer to combine values, or null if none.
- *
- * @param reducer a commutative associative combining function
- * @return the result of accumulating all values
- */
- public V reduceValues(BiFun reducer) {
- return fjp.invoke(ForkJoinTasks.reduceValues
- (ConcurrentHashMapV8.this, reducer));
- }
+ /**
+ * Returns the result of accumulating all values using the
+ * given reducer to combine values, or null if none.
+ *
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating all values
+ */
+ public V reduceValues(BiFun reducer) {
+ return ForkJoinTasks.reduceValues
+ (this, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all values using the given reducer to combine values, or
- * null if none.
- *
- * @param transformer a function returning the transformation
- * for an element, or null if there is no transformation (in
- * which case it is not combined)
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all values
- */
- public U reduceValues(Fun transformer,
- BiFun reducer) {
- return fjp.invoke(ForkJoinTasks.reduceValues
- (ConcurrentHashMapV8.this, transformer, reducer));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all values using the given reducer to combine values, or
+ * null if none.
+ *
+ * @param transformer a function returning the transformation
+ * for an element, or null of there is no transformation (in
+ * which case it is not combined).
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all values
+ */
+ public U reduceValues(Fun transformer,
+ BiFun reducer) {
+ return ForkJoinTasks.reduceValues
+ (this, transformer, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all values using the given reducer to combine values,
- * and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all values
- */
- public double reduceValuesToDouble(ObjectToDouble transformer,
- double basis,
- DoubleByDoubleToDouble reducer) {
- return fjp.invoke(ForkJoinTasks.reduceValuesToDouble
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all values using the given reducer to combine values,
+ * and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all values
+ */
+ public double reduceValuesToDouble(ObjectToDouble transformer,
+ double basis,
+ DoubleByDoubleToDouble reducer) {
+ return ForkJoinTasks.reduceValuesToDouble
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all values using the given reducer to combine values,
- * and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all values
- */
- public long reduceValuesToLong(ObjectToLong transformer,
- long basis,
- LongByLongToLong reducer) {
- return fjp.invoke(ForkJoinTasks.reduceValuesToLong
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all values using the given reducer to combine values,
+ * and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all values
+ */
+ public long reduceValuesToLong(ObjectToLong transformer,
+ long basis,
+ LongByLongToLong reducer) {
+ return ForkJoinTasks.reduceValuesToLong
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all values using the given reducer to combine values,
- * and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all values
- */
- public int reduceValuesToInt(ObjectToInt transformer,
- int basis,
- IntByIntToInt reducer) {
- return fjp.invoke(ForkJoinTasks.reduceValuesToInt
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all values using the given reducer to combine values,
+ * and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all values
+ */
+ public int reduceValuesToInt(ObjectToInt transformer,
+ int basis,
+ IntByIntToInt reducer) {
+ return ForkJoinTasks.reduceValuesToInt
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Performs the given action for each entry.
- *
- * @param action the action
- */
- public void forEachEntry(Action> action) {
- fjp.invoke(ForkJoinTasks.forEachEntry
- (ConcurrentHashMapV8.this, action));
- }
+ /**
+ * Performs the given action for each entry.
+ *
+ * @param action the action
+ */
+ public void forEachEntry(Action> action) {
+ ForkJoinTasks.forEachEntry
+ (this, action).invoke();
+ }
- /**
- * Performs the given action for each non-null transformation
- * of each entry.
- *
- * @param transformer a function returning the transformation
- * for an element, or null if there is no transformation (in
- * which case the action is not applied)
- * @param action the action
- */
- public void forEachEntry(Fun, ? extends U> transformer,
- Action action) {
- fjp.invoke(ForkJoinTasks.forEachEntry
- (ConcurrentHashMapV8.this, transformer, action));
- }
+ /**
+ * Performs the given action for each non-null transformation
+ * of each entry.
+ *
+ * @param transformer a function returning the transformation
+ * for an element, or null of there is no transformation (in
+ * which case the action is not applied).
+ * @param action the action
+ */
+ public void forEachEntry(Fun, ? extends U> transformer,
+ Action action) {
+ ForkJoinTasks.forEachEntry
+ (this, transformer, action).invoke();
+ }
- /**
- * Returns a non-null result from applying the given search
- * function on each entry, or null if none. Upon success,
- * further element processing is suppressed and the results of
- * any other parallel invocations of the search function are
- * ignored.
- *
- * @param searchFunction a function returning a non-null
- * result on success, else null
- * @return a non-null result from applying the given search
- * function on each entry, or null if none
- */
- public U searchEntries(Fun, ? extends U> searchFunction) {
- return fjp.invoke(ForkJoinTasks.searchEntries
- (ConcurrentHashMapV8.this, searchFunction));
- }
+ /**
+ * Returns a non-null result from applying the given search
+ * function on each entry, or null if none. Upon success,
+ * further element processing is suppressed and the results of
+ * any other parallel invocations of the search function are
+ * ignored.
+ *
+ * @param searchFunction a function returning a non-null
+ * result on success, else null
+ * @return a non-null result from applying the given search
+ * function on each entry, or null if none
+ */
+ public U searchEntries(Fun, ? extends U> searchFunction) {
+ return ForkJoinTasks.searchEntries
+ (this, searchFunction).invoke();
+ }
- /**
- * Returns the result of accumulating all entries using the
- * given reducer to combine values, or null if none.
- *
- * @param reducer a commutative associative combining function
- * @return the result of accumulating all entries
- */
- public Map.Entry reduceEntries(BiFun, Map.Entry, ? extends Map.Entry> reducer) {
- return fjp.invoke(ForkJoinTasks.reduceEntries
- (ConcurrentHashMapV8.this, reducer));
- }
+ /**
+ * Returns the result of accumulating all entries using the
+ * given reducer to combine values, or null if none.
+ *
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating all entries
+ */
+ public Map.Entry reduceEntries(BiFun, Map.Entry, ? extends Map.Entry> reducer) {
+ return ForkJoinTasks.reduceEntries
+ (this, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all entries using the given reducer to combine values,
- * or null if none.
- *
- * @param transformer a function returning the transformation
- * for an element, or null if there is no transformation (in
- * which case it is not combined).
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all entries
- */
- public U reduceEntries(Fun, ? extends U> transformer,
- BiFun reducer) {
- return fjp.invoke(ForkJoinTasks.reduceEntries
- (ConcurrentHashMapV8.this, transformer, reducer));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all entries using the given reducer to combine values,
+ * or null if none.
+ *
+ * @param transformer a function returning the transformation
+ * for an element, or null of there is no transformation (in
+ * which case it is not combined).
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all entries
+ */
+ public U reduceEntries(Fun, ? extends U> transformer,
+ BiFun reducer) {
+ return ForkJoinTasks.reduceEntries
+ (this, transformer, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all entries using the given reducer to combine values,
- * and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all entries
- */
- public double reduceEntriesToDouble(ObjectToDouble> transformer,
- double basis,
- DoubleByDoubleToDouble reducer) {
- return fjp.invoke(ForkJoinTasks.reduceEntriesToDouble
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all entries using the given reducer to combine values,
+ * and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all entries
+ */
+ public double reduceEntriesToDouble(ObjectToDouble> transformer,
+ double basis,
+ DoubleByDoubleToDouble reducer) {
+ return ForkJoinTasks.reduceEntriesToDouble
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all entries using the given reducer to combine values,
- * and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all entries
- */
- public long reduceEntriesToLong(ObjectToLong> transformer,
- long basis,
- LongByLongToLong reducer) {
- return fjp.invoke(ForkJoinTasks.reduceEntriesToLong
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all entries using the given reducer to combine values,
+ * and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all entries
+ */
+ public long reduceEntriesToLong(ObjectToLong> transformer,
+ long basis,
+ LongByLongToLong reducer) {
+ return ForkJoinTasks.reduceEntriesToLong
+ (this, transformer, basis, reducer).invoke();
+ }
- /**
- * Returns the result of accumulating the given transformation
- * of all entries using the given reducer to combine values,
- * and the given basis as an identity value.
- *
- * @param transformer a function returning the transformation
- * for an element
- * @param basis the identity (initial default value) for the reduction
- * @param reducer a commutative associative combining function
- * @return the result of accumulating the given transformation
- * of all entries
- */
- public int reduceEntriesToInt(ObjectToInt> transformer,
- int basis,
- IntByIntToInt reducer) {
- return fjp.invoke(ForkJoinTasks.reduceEntriesToInt
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ /**
+ * Returns the result of accumulating the given transformation
+ * of all entries using the given reducer to combine values,
+ * and the given basis as an identity value.
+ *
+ * @param transformer a function returning the transformation
+ * for an element
+ * @param basis the identity (initial default value) for the reduction
+ * @param reducer a commutative associative combining function
+ * @return the result of accumulating the given transformation
+ * of all entries
+ */
+ public int reduceEntriesToInt(ObjectToInt> transformer,
+ int basis,
+ IntByIntToInt reducer) {
+ return ForkJoinTasks.reduceEntriesToInt
+ (this, transformer, basis, reducer).invoke();
}
// ---------------------------------------------------------------------
/**
* Predefined tasks for performing bulk parallel operations on
- * ConcurrentHashMaps. These tasks follow the forms and rules used
- * in class {@link Parallel}. Each method has the same name, but
- * returns a task rather than invoking it. These methods may be
- * useful in custom applications such as submitting a task without
- * waiting for completion, or combining with other tasks.
+ * ConcurrentHashMapV8s. These tasks follow the forms and rules used
+ * for bulk operations. Each method has the same name, but returns
+ * a task rather than invoking it. These methods may be useful in
+ * custom applications such as submitting a task without waiting
+ * for completion, using a custom pool, or combining with other
+ * tasks.
*/
public static class ForkJoinTasks {
private ForkJoinTasks() {}
@@ -4186,7 +4231,7 @@ public class ConcurrentHashMapV8
(ConcurrentHashMapV8 map,
BiAction action) {
if (action == null) throw new NullPointerException();
- return new ForEachMappingTask(map, null, -1, action);
+ return new ForEachMappingTask(map, null, -1, null, action);
}
/**
@@ -4207,7 +4252,7 @@ public class ConcurrentHashMapV8
if (transformer == null || action == null)
throw new NullPointerException();
return new ForEachTransformedMappingTask
- (map, null, -1, transformer, action);
+ (map, null, -1, null, transformer, action);
}
/**
@@ -4227,7 +4272,7 @@ public class ConcurrentHashMapV8
BiFun searchFunction) {
if (searchFunction == null) throw new NullPointerException();
return new SearchMappingsTask
- (map, null, -1, searchFunction,
+ (map, null, -1, null, searchFunction,
new AtomicReference());
}
@@ -4336,7 +4381,7 @@ public class ConcurrentHashMapV8
(ConcurrentHashMapV8 map,
Action action) {
if (action == null) throw new NullPointerException();
- return new ForEachKeyTask(map, null, -1, action);
+ return new ForEachKeyTask(map, null, -1, null, action);
}
/**
@@ -4357,7 +4402,7 @@ public class ConcurrentHashMapV8
if (transformer == null || action == null)
throw new NullPointerException();
return new ForEachTransformedKeyTask
- (map, null, -1, transformer, action);
+ (map, null, -1, null, transformer, action);
}
/**
@@ -4377,7 +4422,7 @@ public class ConcurrentHashMapV8
Fun searchFunction) {
if (searchFunction == null) throw new NullPointerException();
return new SearchKeysTask
- (map, null, -1, searchFunction,
+ (map, null, -1, null, searchFunction,
new AtomicReference());
}
@@ -4503,7 +4548,7 @@ public class ConcurrentHashMapV8
(ConcurrentHashMapV8 map,
Action action) {
if (action == null) throw new NullPointerException();
- return new ForEachValueTask(map, null, -1, action);
+ return new ForEachValueTask(map, null, -1, null, action);
}
/**
@@ -4523,7 +4568,7 @@ public class ConcurrentHashMapV8
if (transformer == null || action == null)
throw new NullPointerException();
return new ForEachTransformedValueTask
- (map, null, -1, transformer, action);
+ (map, null, -1, null, transformer, action);
}
/**
@@ -4543,7 +4588,7 @@ public class ConcurrentHashMapV8
Fun searchFunction) {
if (searchFunction == null) throw new NullPointerException();
return new SearchValuesTask
- (map, null, -1, searchFunction,
+ (map, null, -1, null, searchFunction,
new AtomicReference());
}
@@ -4669,7 +4714,7 @@ public class ConcurrentHashMapV8
(ConcurrentHashMapV8 map,
Action> action) {
if (action == null) throw new NullPointerException();
- return new ForEachEntryTask(map, null, -1, action);
+ return new ForEachEntryTask(map, null, -1, null, action);
}
/**
@@ -4689,7 +4734,7 @@ public class ConcurrentHashMapV8
if (transformer == null || action == null)
throw new NullPointerException();
return new ForEachTransformedEntryTask
- (map, null, -1, transformer, action);
+ (map, null, -1, null, transformer, action);
}
/**
@@ -4709,7 +4754,7 @@ public class ConcurrentHashMapV8
Fun, ? extends U> searchFunction) {
if (searchFunction == null) throw new NullPointerException();
return new SearchEntriesTask
- (map, null, -1, searchFunction,
+ (map, null, -1, null, searchFunction,
new AtomicReference());
}
@@ -4922,13 +4967,16 @@ public class ConcurrentHashMapV8
* dividing by two anyway.
*/
final int batch() {
- ConcurrentHashMapV8 m; int b; Node[] t;
+ ConcurrentHashMapV8 m; int b; Node[] t; ForkJoinPool pool;
if ((b = batch) < 0 && (m = map) != null) { // force initialization
if ((t = tab) == null && (t = tab = m.table) != null)
baseLimit = baseSize = t.length;
if (t != null) {
long n = m.counter.sum();
- int sp = getPool().getParallelism() << 3; // slack of 8
+ int par = (pool = getPool()) == null?
+ ForkJoinPool.getCommonPoolParallelism() :
+ pool.getParallelism();
+ int sp = par << 3; // slack of 8
b = batch = (n <= 0L) ? 0 : (n < (long)sp) ? (int)n : sp;
}
}
@@ -4965,21 +5013,26 @@ public class ConcurrentHashMapV8
@SuppressWarnings("serial") static final class ForEachKeyTask
extends BulkTask {
final Action action;
+ ForEachKeyTask nextRight;
ForEachKeyTask
(ConcurrentHashMapV8 m, BulkTask p, int b,
+ ForEachKeyTask nextRight,
Action action) {
super(m, p, b);
+ this.nextRight = nextRight;
this.action = action;
}
@SuppressWarnings("unchecked") public final boolean exec() {
final Action action = this.action;
if (action == null)
return abortOnNullFunction();
+ ForEachKeyTask rights = null;
try {
int b = batch(), c;
while (b > 1 && baseIndex != baseLimit) {
do {} while (!casPending(c = pending, c+1));
- new ForEachKeyTask(map, this, b >>>= 1, action).fork();
+ (rights = new ForEachKeyTask
+ (map, this, b >>>= 1, rights, action)).fork();
}
while (advance() != null)
action.apply((K)nextKey);
@@ -4987,28 +5040,37 @@ public class ConcurrentHashMapV8
} catch (Throwable ex) {
return tryCompleteComputation(ex);
}
+ while (rights != null && rights.tryUnfork()) {
+ rights.exec();
+ rights = rights.nextRight;
+ }
return false;
}
}
@SuppressWarnings("serial") static final class ForEachValueTask
extends BulkTask {
+ ForEachValueTask nextRight;
final Action action;
ForEachValueTask
(ConcurrentHashMapV8 m, BulkTask p, int b,
+ ForEachValueTask nextRight,
Action action) {
super(m, p, b);
+ this.nextRight = nextRight;
this.action = action;
}
@SuppressWarnings("unchecked") public final boolean exec() {
final Action action = this.action;
if (action == null)
return abortOnNullFunction();
+ ForEachValueTask rights = null;
try {
int b = batch(), c;
while (b > 1 && baseIndex != baseLimit) {
do {} while (!casPending(c = pending, c+1));
- new ForEachValueTask(map, this, b >>>= 1, action).fork();
+ (rights = new ForEachValueTask
+ (map, this, b >>>= 1, rights, action)).fork();
}
Object v;
while ((v = advance()) != null)
@@ -5017,28 +5079,37 @@ public class ConcurrentHashMapV8
} catch (Throwable ex) {
return tryCompleteComputation(ex);
}
+ while (rights != null && rights.tryUnfork()) {
+ rights.exec();
+ rights = rights.nextRight;
+ }
return false;
}
}
@SuppressWarnings("serial") static final class ForEachEntryTask
extends BulkTask {
+ ForEachEntryTask nextRight;
final Action> action;
ForEachEntryTask
(ConcurrentHashMapV8 m, BulkTask p, int b,
+ ForEachEntryTask nextRight,
Action> action) {
super(m, p, b);
+ this.nextRight = nextRight;
this.action = action;
}
@SuppressWarnings("unchecked") public final boolean exec() {
final Action> action = this.action;
if (action == null)
return abortOnNullFunction();
+ ForEachEntryTask rights = null;
try {
int b = batch(), c;
while (b > 1 && baseIndex != baseLimit) {
do {} while (!casPending(c = pending, c+1));
- new ForEachEntryTask(map, this, b >>>= 1, action).fork();
+ (rights = new ForEachEntryTask
+ (map, this, b >>>= 1, rights, action)).fork();
}
Object v;
while ((v = advance()) != null)
@@ -5047,29 +5118,37 @@ public class ConcurrentHashMapV8
} catch (Throwable ex) {
return tryCompleteComputation(ex);
}
+ while (rights != null && rights.tryUnfork()) {
+ rights.exec();
+ rights = rights.nextRight;
+ }
return false;
}
}
@SuppressWarnings("serial") static final class ForEachMappingTask
extends BulkTask {
+ ForEachMappingTask nextRight;
final BiAction action;
ForEachMappingTask
(ConcurrentHashMapV8 m, BulkTask p, int b,
+ ForEachMappingTask nextRight,
BiAction action) {
super(m, p, b);
+ this.nextRight = nextRight;
this.action = action;
}
@SuppressWarnings("unchecked") public final boolean exec() {
final BiAction action = this.action;
if (action == null)
return abortOnNullFunction();
+ ForEachMappingTask rights = null;
try {
int b = batch(), c;
while (b > 1 && baseIndex != baseLimit) {
do {} while (!casPending(c = pending, c+1));
- new ForEachMappingTask(map, this, b >>>= 1,
- action).fork();
+ (rights = new ForEachMappingTask
+ (map, this, b >>>= 1, rights, action)).fork();
}
Object v;
while ((v = advance()) != null)
@@ -5078,19 +5157,26 @@ public class ConcurrentHashMapV8
} catch (Throwable ex) {
return tryCompleteComputation(ex);
}
+ while (rights != null && rights.tryUnfork()) {
+ rights.exec();
+ rights = rights.nextRight;
+ }
return false;
}
}
@SuppressWarnings("serial") static final class ForEachTransformedKeyTask
extends BulkTask {
+ ForEachTransformedKeyTask nextRight;
final Fun transformer;
final Action action;
ForEachTransformedKeyTask
(ConcurrentHashMapV8 m, BulkTask p, int b,
+ ForEachTransformedKeyTask nextRight,
Fun transformer,
Action action) {
super(m, p, b);
+ this.nextRight = nextRight;
this.transformer = transformer;
this.action = action;
@@ -5101,12 +5187,13 @@ public class ConcurrentHashMapV8
final Action action = this.action;
if (transformer == null || action == null)
return abortOnNullFunction();
+ ForEachTransformedKeyTask rights = null;
try {
int b = batch(), c;
while (b > 1 && baseIndex != baseLimit) {
do {} while (!casPending(c = pending, c+1));
- new ForEachTransformedKeyTask
- (map, this, b >>>= 1, transformer, action).fork();
+ (rights = new ForEachTransformedKeyTask
+ (map, this, b >>>= 1, rights, transformer, action)).fork();
}
U u;
while (advance() != null) {
@@ -5117,19 +5204,26 @@ public class ConcurrentHashMapV8
} catch (Throwable ex) {
return tryCompleteComputation(ex);
}
+ while (rights != null && rights.tryUnfork()) {
+ rights.exec();
+ rights = rights.nextRight;
+ }
return false;
}
}
@SuppressWarnings("serial") static final class ForEachTransformedValueTask
extends BulkTask {
+ ForEachTransformedValueTask nextRight;
final Fun transformer;
final Action action;
ForEachTransformedValueTask
(ConcurrentHashMapV8 m, BulkTask p, int b,
+ ForEachTransformedValueTask nextRight,
Fun transformer,
Action action) {
super(m, p, b);
+ this.nextRight = nextRight;
this.transformer = transformer;
this.action = action;
@@ -5140,12 +5234,13 @@ public class ConcurrentHashMapV8
final Action