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 +102,113 @@ 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}. (Tasks 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. (The first three forms are
+ * also available via the {@link #keySet()}, {@link #values()} and
+ * {@link #entrySet()} views). 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,7 @@ public class ConcurrentHashMapV8
Spliterator split();
}
+
/*
* Overview:
*
@@ -461,9 +570,9 @@ public class ConcurrentHashMapV8
private transient volatile int sizeCtl;
// views
- private transient KeySet keySet;
- private transient Values values;
- private transient EntrySet entrySet;
+ private transient KeySetView keySet;
+ private transient ValuesView values;
+ private transient EntrySetView entrySet;
/** For serialization compatibility. Null unless serialized; see below */
private Segment[] segments;
@@ -2243,7 +2352,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,25 +2390,28 @@ 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
int index; // index of bin to use next
int baseIndex; // current index of initial table
int baseLimit; // index bound for initial table
- final int baseSize; // initial table size
+ int baseSize; // initial table size
/** Creates iterator for all entries in the table. */
Traverser(ConcurrentHashMapV8 map) {
- this.tab = (this.map = map).table;
- baseLimit = baseSize = (tab == null) ? 0 : tab.length;
+ this.map = map;
}
/** Creates iterator for split() methods */
Traverser(Traverser it) {
- this.map = it.map;
- this.tab = it.tab;
+ ConcurrentHashMapV8 m; Node[] t;
+ if ((m = this.map = it.map) == null)
+ t = null;
+ else if ((t = it.tab) == null && // force parent tab initialization
+ (t = it.tab = m.table) != null)
+ it.baseLimit = it.baseSize = t.length;
+ this.tab = t;
this.baseSize = it.baseSize;
it.baseLimit = this.index = this.baseIndex =
((this.baseLimit = it.baseLimit) + it.baseIndex + 1) >>> 1;
@@ -2309,17 +2422,24 @@ 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
e = e.next;
while (e == null) { // get to next non-null bin
+ ConcurrentHashMapV8 m;
Node[] t; int b, i, n; Object ek; // checks must use locals
- if ((b = baseIndex) >= baseLimit || (i = index) < 0 ||
- (t = tab) == null || i >= (n = t.length))
+ if ((t = tab) != null)
+ n = t.length;
+ else if ((m = map) != null && (t = tab = m.table) != null)
+ n = baseLimit = baseSize = t.length;
+ else
break outer;
- else if ((e = tabAt(t, i)) != null && e.hash == MOVED) {
+ if ((b = baseIndex) >= baseLimit ||
+ (i = index) < 0 || i >= n)
+ break outer;
+ if ((e = tabAt(t, i)) != null && e.hash == MOVED) {
if ((ek = e.key) instanceof TreeBin)
e = ((TreeBin)ek).first;
else {
@@ -2336,13 +2456,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() {
@@ -2446,6 +2563,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() {
@@ -2464,7 +2607,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.
@@ -2495,11 +2638,11 @@ public class ConcurrentHashMapV8
/**
* Returns the value to which the specified key is mapped,
- * or the gieven defaultValue if this map contains no mapping for the key.
+ * or the given defaultValue if this map contains no mapping for the key.
*
* @param key the key
* @param defaultValue the value to return if this map contains
- * no mapping for the given key.
+ * no mapping for the given key
* @return the mapping for the key, if present; else the defaultValue
* @throws NullPointerException if the specified key is null
*/
@@ -2639,7 +2782,7 @@ public class ConcurrentHashMapV8
* @param key key with which the specified value is to be associated
* @param mappingFunction the function to compute a value
* @return the current (existing or computed) value associated with
- * the specified key, or null if the computed value is null.
+ * the specified key, or null if the computed value is null
* @throws NullPointerException if the specified key or mappingFunction
* is null
* @throws IllegalStateException if the computation detectably
@@ -2837,43 +2980,41 @@ 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);
}
/**
* Returns a {@link Collection} view of the values contained in this map.
* The collection is backed by the map, so changes to the map are
- * reflected in the collection, and vice-versa. The collection
- * supports element removal, which removes the corresponding
- * mapping from this map, via the {@code Iterator.remove},
- * {@code Collection.remove}, {@code removeAll},
- * {@code retainAll}, and {@code clear} operations. It does not
- * support the {@code add} or {@code addAll} operations.
- *
- * 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.
+ * reflected in the collection, and vice-versa.
*/
- public Collection values() {
- Values vs = values;
- return (vs != null) ? vs : (values = new Values(this));
+ public ValuesView values() {
+ ValuesView vs = values;
+ return (vs != null) ? vs : (values = new ValuesView(this));
}
/**
@@ -2893,8 +3034,8 @@ public class ConcurrentHashMapV8
* reflect any modifications subsequent to construction.
*/
public Set> entrySet() {
- EntrySet es = entrySet;
- return (es != null) ? es : (entrySet = new EntrySet(this));
+ EntrySetView es = entrySet;
+ return (es != null) ? es : (entrySet = new EntrySetView(this));
}
/**
@@ -3034,7 +3175,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);
}
@@ -3056,7 +3197,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);
}
@@ -3079,7 +3220,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);
}
@@ -3137,223 +3278,6 @@ public class ConcurrentHashMapV8
}
}
- /* ----------------Views -------------- */
-
- /**
- * Base class for views.
- */
- static abstract class CHMView {
- final ConcurrentHashMapV8 map;
- CHMView(ConcurrentHashMapV8 map) { this.map = map; }
- public final int size() { return map.size(); }
- public final boolean isEmpty() { return map.isEmpty(); }
- public final void clear() { map.clear(); }
-
- // implementations below rely on concrete classes supplying these
- abstract public Iterator iterator();
- abstract public boolean contains(Object o);
- abstract public boolean remove(Object o);
-
- private static final String oomeMsg = "Required array size too large";
-
- public final Object[] toArray() {
- long sz = map.mappingCount();
- if (sz > (long)(MAX_ARRAY_SIZE))
- throw new OutOfMemoryError(oomeMsg);
- int n = (int)sz;
- Object[] r = new Object[n];
- int i = 0;
- Iterator it = iterator();
- while (it.hasNext()) {
- if (i == n) {
- if (n >= MAX_ARRAY_SIZE)
- throw new OutOfMemoryError(oomeMsg);
- if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
- n = MAX_ARRAY_SIZE;
- else
- n += (n >>> 1) + 1;
- r = Arrays.copyOf(r, n);
- }
- r[i++] = it.next();
- }
- return (i == n) ? r : Arrays.copyOf(r, i);
- }
-
- @SuppressWarnings("unchecked") public final T[] toArray(T[] a) {
- long sz = map.mappingCount();
- if (sz > (long)(MAX_ARRAY_SIZE))
- throw new OutOfMemoryError(oomeMsg);
- int m = (int)sz;
- T[] r = (a.length >= m) ? a :
- (T[])java.lang.reflect.Array
- .newInstance(a.getClass().getComponentType(), m);
- int n = r.length;
- int i = 0;
- Iterator it = iterator();
- while (it.hasNext()) {
- if (i == n) {
- if (n >= MAX_ARRAY_SIZE)
- throw new OutOfMemoryError(oomeMsg);
- if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
- n = MAX_ARRAY_SIZE;
- else
- n += (n >>> 1) + 1;
- r = Arrays.copyOf(r, n);
- }
- r[i++] = (T)it.next();
- }
- if (a == r && i < n) {
- r[i] = null; // null-terminate
- return r;
- }
- return (i == n) ? r : Arrays.copyOf(r, i);
- }
-
- public final int hashCode() {
- int h = 0;
- for (Iterator it = iterator(); it.hasNext();)
- h += it.next().hashCode();
- return h;
- }
-
- public final String toString() {
- StringBuilder sb = new StringBuilder();
- sb.append('[');
- Iterator it = iterator();
- if (it.hasNext()) {
- for (;;) {
- Object e = it.next();
- sb.append(e == this ? "(this Collection)" : e);
- if (!it.hasNext())
- break;
- sb.append(',').append(' ');
- }
- }
- return sb.append(']').toString();
- }
-
- public final boolean containsAll(Collection c) {
- if (c != this) {
- for (Iterator it = c.iterator(); it.hasNext();) {
- Object e = it.next();
- if (e == null || !contains(e))
- return false;
- }
- }
- return true;
- }
-
- public final boolean removeAll(Collection c) {
- boolean modified = false;
- for (Iterator it = iterator(); it.hasNext();) {
- if (c.contains(it.next())) {
- it.remove();
- modified = true;
- }
- }
- return modified;
- }
-
- public final boolean retainAll(Collection c) {
- boolean modified = false;
- for (Iterator it = iterator(); it.hasNext();) {
- if (!c.contains(it.next())) {
- it.remove();
- modified = true;
- }
- }
- return modified;
- }
-
- }
-
- 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); }
- public final boolean contains(Object o) { return map.containsValue(o); }
- public final boolean remove(Object o) {
- if (o != null) {
- Iterator it = new ValueIterator(map);
- while (it.hasNext()) {
- if (o.equals(it.next())) {
- it.remove();
- return true;
- }
- }
- }
- return false;
- }
- public final Iterator iterator() {
- return new ValueIterator(map);
- }
- public final boolean add(V e) {
- throw new UnsupportedOperationException();
- }
- public final boolean addAll(Collection c) {
- throw new UnsupportedOperationException();
- }
-
- }
-
- static final class EntrySet extends CHMView
- implements Set> {
- EntrySet(ConcurrentHashMapV8 map) { super(map); }
- public final boolean contains(Object o) {
- Object k, v, r; Map.Entry e;
- return ((o instanceof Map.Entry) &&
- (k = (e = (Map.Entry)o).getKey()) != null &&
- (r = map.get(k)) != null &&
- (v = e.getValue()) != null &&
- (v == r || v.equals(r)));
- }
- public final boolean remove(Object o) {
- Object k, v; Map.Entry e;
- return ((o instanceof Map.Entry) &&
- (k = (e = (Map.Entry)o).getKey()) != null &&
- (v = e.getValue()) != null &&
- map.remove(k, v));
- }
- public final Iterator> iterator() {
- return new EntryIterator(map);
- }
- public final boolean add(Entry 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))));
- }
- }
-
/* ---------------- Serialization Support -------------- */
/**
@@ -3520,246 +3444,714 @@ 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.
- */
- public class Parallel {
- final ForkJoinPool fjp;
-
- /**
- * 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;
- }
+ * 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 void forEach(BiFun transformer,
+ Action action) {
+ ForkJoinTasks.forEach
+ (this, transformer, action).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 ForkJoinTasks.search
+ (this, searchFunction).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 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();
+ }
+
+ /**
+ * 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 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, 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 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 ForkJoinTasks.searchKeys
+ (this, searchFunction).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 ForkJoinTasks.reduceKeys
+ (this, transformer, reducer).invoke();
+ }
+
+ /**
+ * 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 ForkJoinTasks.reduceKeysToDouble
+ (this, transformer, basis, reducer).invoke();
+ }
+
+ /**
+ * 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 ForkJoinTasks.reduceKeysToLong
+ (this, transformer, basis, reducer).invoke();
+ }
+
+ /**
+ * 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 ForkJoinTasks.reduceKeysToInt
+ (this, transformer, basis, reducer).invoke();
+ }
+
+ /**
+ * 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 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 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 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 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 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 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 ForkJoinTasks.reduceValuesToInt
+ (this, transformer, basis, reducer).invoke();
+ }
+
+ /**
+ * 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 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 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 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 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 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 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 ForkJoinTasks.reduceEntriesToInt
+ (this, transformer, basis, reducer).invoke();
+ }
+
+ /* ----------------Views -------------- */
+
+ /**
+ * Base class for views.
+ */
+ static abstract class CHMView {
+ final ConcurrentHashMapV8 map;
+ CHMView(ConcurrentHashMapV8 map) { this.map = map; }
/**
- * Performs the given action for each (key, value).
+ * Returns the map backing this view.
*
- * @param action the action
+ * @return the map backing this view
*/
- public void forEach(BiAction action) {
- fjp.invoke(ForkJoinTasks.forEach
- (ConcurrentHashMapV8.this, action));
+ public ConcurrentHashMapV8 getMap() { return map; }
+
+ public final int size() { return map.size(); }
+ public final boolean isEmpty() { return map.isEmpty(); }
+ public final void clear() { map.clear(); }
+
+ // implementations below rely on concrete classes supplying these
+ abstract public Iterator iterator();
+ abstract public boolean contains(Object o);
+ abstract public boolean remove(Object o);
+
+ private static final String oomeMsg = "Required array size too large";
+
+ public final Object[] toArray() {
+ long sz = map.mappingCount();
+ if (sz > (long)(MAX_ARRAY_SIZE))
+ throw new OutOfMemoryError(oomeMsg);
+ int n = (int)sz;
+ Object[] r = new Object[n];
+ int i = 0;
+ Iterator it = iterator();
+ while (it.hasNext()) {
+ if (i == n) {
+ if (n >= MAX_ARRAY_SIZE)
+ throw new OutOfMemoryError(oomeMsg);
+ if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
+ n = MAX_ARRAY_SIZE;
+ else
+ n += (n >>> 1) + 1;
+ r = Arrays.copyOf(r, n);
+ }
+ r[i++] = it.next();
+ }
+ return (i == n) ? r : Arrays.copyOf(r, i);
}
- /**
- * 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 void forEach(BiFun transformer,
- Action action) {
- fjp.invoke(ForkJoinTasks.forEach
- (ConcurrentHashMapV8.this, transformer, action));
+ @SuppressWarnings("unchecked") public final T[] toArray(T[] a) {
+ long sz = map.mappingCount();
+ if (sz > (long)(MAX_ARRAY_SIZE))
+ throw new OutOfMemoryError(oomeMsg);
+ int m = (int)sz;
+ T[] r = (a.length >= m) ? a :
+ (T[])java.lang.reflect.Array
+ .newInstance(a.getClass().getComponentType(), m);
+ int n = r.length;
+ int i = 0;
+ Iterator it = iterator();
+ while (it.hasNext()) {
+ if (i == n) {
+ if (n >= MAX_ARRAY_SIZE)
+ throw new OutOfMemoryError(oomeMsg);
+ if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
+ n = MAX_ARRAY_SIZE;
+ else
+ n += (n >>> 1) + 1;
+ r = Arrays.copyOf(r, n);
+ }
+ r[i++] = (T)it.next();
+ }
+ if (a == r && i < n) {
+ r[i] = null; // null-terminate
+ return r;
+ }
+ return (i == n) ? r : Arrays.copyOf(r, i);
}
- /**
- * 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));
+ public final int hashCode() {
+ int h = 0;
+ for (Iterator it = iterator(); it.hasNext();)
+ h += it.next().hashCode();
+ return h;
}
- /**
- * 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 fjp.invoke(ForkJoinTasks.reduce
- (ConcurrentHashMapV8.this, transformer, reducer));
+ public final String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append('[');
+ Iterator it = iterator();
+ if (it.hasNext()) {
+ for (;;) {
+ Object e = it.next();
+ sb.append(e == this ? "(this Collection)" : e);
+ if (!it.hasNext())
+ break;
+ sb.append(',').append(' ');
+ }
+ }
+ return sb.append(']').toString();
}
- /**
- * 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 fjp.invoke(ForkJoinTasks.reduceToDouble
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
+ public final boolean containsAll(Collection c) {
+ if (c != this) {
+ for (Iterator it = c.iterator(); it.hasNext();) {
+ Object e = it.next();
+ if (e == null || !contains(e))
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public final boolean removeAll(Collection c) {
+ boolean modified = false;
+ for (Iterator it = iterator(); it.hasNext();) {
+ if (c.contains(it.next())) {
+ it.remove();
+ modified = true;
+ }
+ }
+ return modified;
+ }
+
+ public final boolean retainAll(Collection c) {
+ boolean modified = false;
+ for (Iterator it = iterator(); it.hasNext();) {
+ if (!c.contains(it.next())) {
+ it.remove();
+ modified = true;
+ }
+ }
+ return modified;
+ }
+
+ }
+
+ /**
+ * 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)}.
+ */
+ 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 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.
+ * Returns the default mapped value for additions,
+ * or {@code null} if additions are not supported.
*
- * @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
+ * @return the default mapped value for additions, or {@code null}
+ * if not supported.
*/
- public long reduceToLong(ObjectByObjectToLong transformer,
- long basis,
- LongByLongToLong reducer) {
- return fjp.invoke(ForkJoinTasks.reduceToLong
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
- }
+ 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; }
/**
- * 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.
+ * Returns 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.
*
- * @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
+ * @return an iterator over the keys of this map
*/
- public int reduceToInt(ObjectByObjectToInt transformer,
- int basis,
- IntByIntToInt reducer) {
- return fjp.invoke(ForkJoinTasks.reduceToInt
- (ConcurrentHashMapV8.this, transformer, basis, reducer));
+ 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))));
}
/**
@@ -3767,9 +4159,9 @@ public class ConcurrentHashMapV8
*
* @param action the action
*/
- public void forEachKey(Action action) {
- fjp.invoke(ForkJoinTasks.forEachKey
- (ConcurrentHashMapV8.this, action));
+ public void forEach(Action action) {
+ ForkJoinTasks.forEachKey
+ (map, action).invoke();
}
/**
@@ -3781,10 +4173,10 @@ public class ConcurrentHashMapV8
* 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));
+ public void forEach(Fun transformer,
+ Action action) {
+ ForkJoinTasks.forEachKey
+ (map, transformer, action).invoke();
}
/**
@@ -3799,9 +4191,9 @@ public class ConcurrentHashMapV8
* @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));
+ public U search(Fun searchFunction) {
+ return ForkJoinTasks.searchKeys
+ (map, searchFunction).invoke();
}
/**
@@ -3812,27 +4204,9 @@ public class ConcurrentHashMapV8
* @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 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.reduceKeys
- (ConcurrentHashMapV8.this, transformer, reducer));
+ public K reduce(BiFun reducer) {
+ return ForkJoinTasks.reduceKeys
+ (map, reducer).invoke();
}
/**
@@ -3847,13 +4221,14 @@ public class ConcurrentHashMapV8
* @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));
+ public double reduceToDouble(ObjectToDouble transformer,
+ double basis,
+ DoubleByDoubleToDouble reducer) {
+ return ForkJoinTasks.reduceKeysToDouble
+ (map, transformer, basis, reducer).invoke();
}
+
/**
* Returns the result of accumulating the given transformation
* of all keys using the given reducer to combine values, and
@@ -3866,11 +4241,11 @@ public class ConcurrentHashMapV8
* @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));
+ public long reduceToLong(ObjectToLong transformer,
+ long basis,
+ LongByLongToLong reducer) {
+ return ForkJoinTasks.reduceKeysToLong
+ (map, transformer, basis, reducer).invoke();
}
/**
@@ -3885,11 +4260,61 @@ public class ConcurrentHashMapV8
* @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));
+ public int reduceToInt(ObjectToInt transformer,
+ int basis,
+ IntByIntToInt reducer) {
+ return ForkJoinTasks.reduceKeysToInt
+ (map, transformer, basis, reducer).invoke();
+ }
+
+ }
+
+ /**
+ * A view of a ConcurrentHashMapV8 as a {@link Collection} of
+ * values, in which additions are disabled. This class cannot be
+ * directly instantiated. See {@link #values},
+ *
+ * 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 final class ValuesView extends CHMView
+ implements Collection {
+ ValuesView(ConcurrentHashMapV8 map) { super(map); }
+ public final boolean contains(Object o) { return map.containsValue(o); }
+ public final boolean remove(Object o) {
+ if (o != null) {
+ Iterator it = new ValueIterator(map);
+ while (it.hasNext()) {
+ if (o.equals(it.next())) {
+ it.remove();
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns 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 an iterator over the values of this map
+ */
+ public final Iterator iterator() {
+ return new ValueIterator(map);
+ }
+ public final boolean add(V e) {
+ throw new UnsupportedOperationException();
+ }
+ public final boolean addAll(Collection c) {
+ throw new UnsupportedOperationException();
}
/**
@@ -3897,9 +4322,9 @@ public class ConcurrentHashMapV8
*
* @param action the action
*/
- public void forEachValue(Action action) {
- fjp.invoke(ForkJoinTasks.forEachValue
- (ConcurrentHashMapV8.this, action));
+ public void forEach(Action action) {
+ ForkJoinTasks.forEachValue
+ (map, action).invoke();
}
/**
@@ -3910,10 +4335,10 @@ public class ConcurrentHashMapV8
* for an element, or null of there is no transformation (in
* which case the action is not applied).
*/
- public void forEachValue(Fun transformer,
+ public void forEach(Fun transformer,
Action action) {
- fjp.invoke(ForkJoinTasks.forEachValue
- (ConcurrentHashMapV8.this, transformer, action));
+ ForkJoinTasks.forEachValue
+ (map, transformer, action).invoke();
}
/**
@@ -3929,9 +4354,9 @@ public class ConcurrentHashMapV8
* function on each value, or null if none
*
*/
- public U searchValues(Fun searchFunction) {
- return fjp.invoke(ForkJoinTasks.searchValues
- (ConcurrentHashMapV8.this, searchFunction));
+ public U search(Fun searchFunction) {
+ return ForkJoinTasks.searchValues
+ (map, searchFunction).invoke();
}
/**
@@ -3941,9 +4366,9 @@ public class ConcurrentHashMapV8
* @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));
+ public V reduce(BiFun reducer) {
+ return ForkJoinTasks.reduceValues
+ (map, reducer).invoke();
}
/**
@@ -3958,10 +4383,10 @@ public class ConcurrentHashMapV8
* @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));
+ public U reduce(Fun transformer,
+ BiFun reducer) {
+ return ForkJoinTasks.reduceValues
+ (map, transformer, reducer).invoke();
}
/**
@@ -3976,11 +4401,11 @@ public class ConcurrentHashMapV8
* @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));
+ public double reduceToDouble(ObjectToDouble transformer,
+ double basis,
+ DoubleByDoubleToDouble reducer) {
+ return ForkJoinTasks.reduceValuesToDouble
+ (map, transformer, basis, reducer).invoke();
}
/**
@@ -3995,11 +4420,11 @@ public class ConcurrentHashMapV8
* @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));
+ public long reduceToLong(ObjectToLong transformer,
+ long basis,
+ LongByLongToLong reducer) {
+ return ForkJoinTasks.reduceValuesToLong
+ (map, transformer, basis, reducer).invoke();
}
/**
@@ -4014,11 +4439,73 @@ public class ConcurrentHashMapV8
* @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));
+ public int reduceToInt(ObjectToInt transformer,
+ int basis,
+ IntByIntToInt reducer) {
+ return ForkJoinTasks.reduceValuesToInt
+ (map, transformer, basis, reducer).invoke();
+ }
+
+ }
+
+ /**
+ * A view of a ConcurrentHashMapV8 as a {@link Set} of (key, value)
+ * entries. This class cannot be directly instantiated. See
+ * {@link #entrySet}.
+ */
+ public static final class EntrySetView extends CHMView
+ implements Set> {
+ EntrySetView(ConcurrentHashMapV8 map) { super(map); }
+ public final boolean contains(Object o) {
+ Object k, v, r; Map.Entry e;
+ return ((o instanceof Map.Entry) &&
+ (k = (e = (Map.Entry)o).getKey()) != null &&
+ (r = map.get(k)) != null &&
+ (v = e.getValue()) != null &&
+ (v == r || v.equals(r)));
+ }
+ public final boolean remove(Object o) {
+ Object k, v; Map.Entry e;
+ return ((o instanceof Map.Entry) &&
+ (k = (e = (Map.Entry)o).getKey()) != null &&
+ (v = e.getValue()) != null &&
+ map.remove(k, v));
+ }
+
+ /**
+ * Returns 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 an iterator over the entries of this map
+ */
+ public final Iterator> iterator() {
+ return new EntryIterator(map);
+ }
+
+ public final boolean add(Entry e) {
+ K key = e.getKey();
+ V value = e.getValue();
+ if (key == null || value == null)
+ throw new NullPointerException();
+ return map.internalPut(key, value) == null;
+ }
+ public final boolean addAll(Collection> c) {
+ boolean added = false;
+ for (Entry e : c) {
+ if (add(e))
+ added = true;
+ }
+ return added;
+ }
+ public boolean equals(Object o) {
+ Set c;
+ return ((o instanceof Set) &&
+ ((c = (Set)o) == this ||
+ (containsAll(c) && c.containsAll(this))));
}
/**
@@ -4026,9 +4513,9 @@ public class ConcurrentHashMapV8
*
* @param action the action
*/
- public void forEachEntry(Action> action) {
- fjp.invoke(ForkJoinTasks.forEachEntry
- (ConcurrentHashMapV8.this, action));
+ public void forEach(Action> action) {
+ ForkJoinTasks.forEachEntry
+ (map, action).invoke();
}
/**
@@ -4040,10 +4527,10 @@ public class ConcurrentHashMapV8
* 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));
+ public void forEach(Fun, ? extends U> transformer,
+ Action action) {
+ ForkJoinTasks.forEachEntry
+ (map, transformer, action).invoke();
}
/**
@@ -4058,9 +4545,9 @@ public class ConcurrentHashMapV8
* @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));
+ public U search(Fun, ? extends U> searchFunction) {
+ return ForkJoinTasks.searchEntries
+ (map, searchFunction).invoke();
}
/**
@@ -4070,9 +4557,9 @@ public class ConcurrentHashMapV8
* @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));
+ public Map.Entry reduce(BiFun, Map.Entry, ? extends Map.Entry> reducer) {
+ return ForkJoinTasks.reduceEntries
+ (map, reducer).invoke();
}
/**
@@ -4087,10 +4574,10 @@ public class ConcurrentHashMapV8
* @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));
+ public U reduce(Fun, ? extends U> transformer,
+ BiFun reducer) {
+ return ForkJoinTasks.reduceEntries
+ (map, transformer, reducer).invoke();
}
/**
@@ -4105,11 +4592,11 @@ public class ConcurrentHashMapV8
* @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));
+ public double reduceToDouble(ObjectToDouble> transformer,
+ double basis,
+ DoubleByDoubleToDouble reducer) {
+ return ForkJoinTasks.reduceEntriesToDouble
+ (map, transformer, basis, reducer).invoke();
}
/**
@@ -4124,11 +4611,11 @@ public class ConcurrentHashMapV8
* @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));
+ public long reduceToLong(ObjectToLong> transformer,
+ long basis,
+ LongByLongToLong reducer) {
+ return ForkJoinTasks.reduceEntriesToLong
+ (map, transformer, basis, reducer).invoke();
}
/**
@@ -4143,23 +4630,25 @@ public class ConcurrentHashMapV8
* @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));
+ public int reduceToInt(ObjectToInt> transformer,
+ int basis,
+ IntByIntToInt reducer) {
+ return ForkJoinTasks.reduceEntriesToInt
+ (map, 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() {}
@@ -4176,7 +4665,7 @@ public class ConcurrentHashMapV8
(ConcurrentHashMapV8 map,
BiAction action) {
if (action == null) throw new NullPointerException();
- return new ForEachMappingTask(map, action);
+ return new ForEachMappingTask(map, null, -1, null, action);
}
/**
@@ -4185,8 +4674,8 @@ public class ConcurrentHashMapV8
*
* @param map the map
* @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).
+ * for an element, or null if there is no transformation (in
+ * which case the action is not applied)
* @param action the action
* @return the task
*/
@@ -4197,7 +4686,7 @@ public class ConcurrentHashMapV8
if (transformer == null || action == null)
throw new NullPointerException();
return new ForEachTransformedMappingTask
- (map, transformer, action);
+ (map, null, -1, null, transformer, action);
}
/**
@@ -4217,7 +4706,7 @@ public class ConcurrentHashMapV8
BiFun searchFunction) {
if (searchFunction == null) throw new NullPointerException();
return new SearchMappingsTask
- (map, searchFunction,
+ (map, null, -1, null, searchFunction,
new AtomicReference());
}
@@ -4228,7 +4717,7 @@ public class ConcurrentHashMapV8
*
* @param map the map
* @param transformer a function returning the transformation
- * for an element, or null of there is no transformation (in
+ * 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 task
@@ -4240,7 +4729,7 @@ public class ConcurrentHashMapV8
if (transformer == null || reducer == null)
throw new NullPointerException();
return new MapReduceMappingsTask
- (map, transformer, reducer);
+ (map, null, -1, null, transformer, reducer);
}
/**
@@ -4264,7 +4753,7 @@ public class ConcurrentHashMapV8
if (transformer == null || reducer == null)
throw new NullPointerException();
return new MapReduceMappingsToDoubleTask
- (map, transformer, basis, reducer);
+ (map, null, -1, null, transformer, basis, reducer);
}
/**
@@ -4288,7 +4777,7 @@ public class ConcurrentHashMapV8
if (transformer == null || reducer == null)
throw new NullPointerException();
return new MapReduceMappingsToLongTask
- (map, transformer, basis, reducer);
+ (map, null, -1, null, transformer, basis, reducer);
}
/**
@@ -4311,7 +4800,7 @@ public class ConcurrentHashMapV8
if (transformer == null || reducer == null)
throw new NullPointerException();
return new MapReduceMappingsToIntTask