ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/jsr166e/ConcurrentHashMapV8.java
(Generate patch)

Comparing jsr166/src/jsr166e/ConcurrentHashMapV8.java (file contents):
Revision 1.61 by dl, Thu Sep 13 10:41:37 2012 UTC vs.
Revision 1.78 by jsr166, Sun Nov 18 18:03:10 2012 UTC

# Line 5 | Line 5
5   */
6  
7   package jsr166e;
8 – import jsr166e.LongAdder;
9 – import jsr166e.ForkJoinPool;
10 – import jsr166e.ForkJoinTask;
8  
9   import java.util.Comparator;
10   import java.util.Arrays;
# Line 43 | Line 40 | import java.io.Serializable;
40   * interoperable with {@code Hashtable} in programs that rely on its
41   * thread safety but not on its synchronization details.
42   *
43 < * <p> Retrieval operations (including {@code get}) generally do not
43 > * <p>Retrieval operations (including {@code get}) generally do not
44   * block, so may overlap with update operations (including {@code put}
45   * and {@code remove}). Retrievals reflect the results of the most
46   * recently <em>completed</em> update operations holding upon their
# Line 64 | Line 61 | import java.io.Serializable;
61   * that may be adequate for monitoring or estimation purposes, but not
62   * for program control.
63   *
64 < * <p> The table is dynamically expanded when there are too many
64 > * <p>The table is dynamically expanded when there are too many
65   * collisions (i.e., keys that have distinct hash codes but fall into
66   * the same slot modulo the table size), with the expected average
67   * effect of maintaining roughly two bins per mapping (corresponding
# Line 85 | Line 82 | import java.io.Serializable;
82   * {@code hashCode()} is a sure way to slow down performance of any
83   * hash table.
84   *
85 + * <p>A {@link Set} projection of a ConcurrentHashMapV8 may be created
86 + * (using {@link #newKeySet()} or {@link #newKeySet(int)}), or viewed
87 + * (using {@link #keySet(Object)} when only keys are of interest, and the
88 + * mapped values are (perhaps transiently) not used or all take the
89 + * same mapping value.
90 + *
91 + * <p>A ConcurrentHashMapV8 can be used as scalable frequency map (a
92 + * form of histogram or multiset) by using {@link LongAdder} values
93 + * and initializing via {@link #computeIfAbsent}. For example, to add
94 + * a count to a {@code ConcurrentHashMapV8<String,LongAdder> freqs}, you
95 + * can use {@code freqs.computeIfAbsent(k -> new
96 + * LongAdder()).increment();}
97 + *
98   * <p>This class and its views and iterators implement all of the
99   * <em>optional</em> methods of the {@link Map} and {@link Iterator}
100   * interfaces.
101   *
102 < * <p> Like {@link Hashtable} but unlike {@link HashMap}, this class
102 > * <p>Like {@link Hashtable} but unlike {@link HashMap}, this class
103   * does <em>not</em> allow {@code null} to be used as a key or value.
104   *
105 + * <p>ConcurrentHashMapV8s support parallel operations using the {@link
106 + * ForkJoinPool#commonPool}. (Tasks that may be used in other contexts
107 + * are available in class {@link ForkJoinTasks}). These operations are
108 + * designed to be safely, and often sensibly, applied even with maps
109 + * that are being concurrently updated by other threads; for example,
110 + * when computing a snapshot summary of the values in a shared
111 + * registry.  There are three kinds of operation, each with four
112 + * forms, accepting functions with Keys, Values, Entries, and (Key,
113 + * Value) arguments and/or return values. (The first three forms are
114 + * also available via the {@link #keySet()}, {@link #values()} and
115 + * {@link #entrySet()} views). Because the elements of a
116 + * ConcurrentHashMapV8 are not ordered in any particular way, and may be
117 + * processed in different orders in different parallel executions, the
118 + * correctness of supplied functions should not depend on any
119 + * ordering, or on any other objects or values that may transiently
120 + * change while computation is in progress; and except for forEach
121 + * actions, should ideally be side-effect-free.
122 + *
123 + * <ul>
124 + * <li> forEach: Perform a given action on each element.
125 + * A variant form applies a given transformation on each element
126 + * before performing the action.</li>
127 + *
128 + * <li> search: Return the first available non-null result of
129 + * applying a given function on each element; skipping further
130 + * search when a result is found.</li>
131 + *
132 + * <li> reduce: Accumulate each element.  The supplied reduction
133 + * function cannot rely on ordering (more formally, it should be
134 + * both associative and commutative).  There are five variants:
135 + *
136 + * <ul>
137 + *
138 + * <li> Plain reductions. (There is not a form of this method for
139 + * (key, value) function arguments since there is no corresponding
140 + * return type.)</li>
141 + *
142 + * <li> Mapped reductions that accumulate the results of a given
143 + * function applied to each element.</li>
144 + *
145 + * <li> Reductions to scalar doubles, longs, and ints, using a
146 + * given basis value.</li>
147 + *
148 + * </li>
149 + * </ul>
150 + * </ul>
151 + *
152 + * <p>The concurrency properties of bulk operations follow
153 + * from those of ConcurrentHashMapV8: Any non-null result returned
154 + * from {@code get(key)} and related access methods bears a
155 + * happens-before relation with the associated insertion or
156 + * update.  The result of any bulk operation reflects the
157 + * composition of these per-element relations (but is not
158 + * necessarily atomic with respect to the map as a whole unless it
159 + * is somehow known to be quiescent).  Conversely, because keys
160 + * and values in the map are never null, null serves as a reliable
161 + * atomic indicator of the current lack of any result.  To
162 + * maintain this property, null serves as an implicit basis for
163 + * all non-scalar reduction operations. For the double, long, and
164 + * int versions, the basis should be one that, when combined with
165 + * any other value, returns that other value (more formally, it
166 + * should be the identity element for the reduction). Most common
167 + * reductions have these properties; for example, computing a sum
168 + * with basis 0 or a minimum with basis MAX_VALUE.
169 + *
170 + * <p>Search and transformation functions provided as arguments
171 + * should similarly return null to indicate the lack of any result
172 + * (in which case it is not used). In the case of mapped
173 + * reductions, this also enables transformations to serve as
174 + * filters, returning null (or, in the case of primitive
175 + * specializations, the identity basis) if the element should not
176 + * be combined. You can create compound transformations and
177 + * filterings by composing them yourself under this "null means
178 + * there is nothing there now" rule before using them in search or
179 + * reduce operations.
180 + *
181 + * <p>Methods accepting and/or returning Entry arguments maintain
182 + * key-value associations. They may be useful for example when
183 + * finding the key for the greatest value. Note that "plain" Entry
184 + * arguments can be supplied using {@code new
185 + * AbstractMap.SimpleEntry(k,v)}.
186 + *
187 + * <p>Bulk operations may complete abruptly, throwing an
188 + * exception encountered in the application of a supplied
189 + * function. Bear in mind when handling such exceptions that other
190 + * concurrently executing functions could also have thrown
191 + * exceptions, or would have done so if the first exception had
192 + * not occurred.
193 + *
194 + * <p>Parallel speedups for bulk operations compared to sequential
195 + * processing are common but not guaranteed.  Operations involving
196 + * brief functions on small maps may execute more slowly than
197 + * sequential loops if the underlying work to parallelize the
198 + * computation is more expensive than the computation itself.
199 + * Similarly, parallelization may not lead to much actual parallelism
200 + * if all processors are busy performing unrelated tasks.
201 + *
202 + * <p>All arguments to all task methods must be non-null.
203 + *
204 + * <p><em>jsr166e note: During transition, this class
205 + * uses nested functional interfaces with different names but the
206 + * same forms as those expected for JDK8.</em>
207 + *
208   * <p>This class is a member of the
209   * <a href="{@docRoot}/../technotes/guides/collections/index.html">
210   * Java Collections Framework</a>.
211   *
99 – * <p><em>jsr166e note: This class is a candidate replacement for
100 – * java.util.concurrent.ConcurrentHashMap.  During transition, this
101 – * class declares and uses nested functional interfaces with different
102 – * names but the same forms as those expected for JDK8.<em>
103 – *
212   * @since 1.5
213   * @author Doug Lea
214   * @param <K> the type of keys maintained by this map
# Line 117 | Line 225 | public class ConcurrentHashMapV8<K, V>
225       * portion of the elements, and so may be amenable to parallel
226       * execution.
227       *
228 <     * <p> This interface exports a subset of expected JDK8
228 >     * <p>This interface exports a subset of expected JDK8
229       * functionality.
230       *
231       * <p>Sample usage: Here is one (of the several) ways to compute
# Line 179 | Line 287 | public class ConcurrentHashMapV8<K, V>
287          Spliterator<T> split();
288      }
289  
290 +
291      /*
292       * Overview:
293       *
# Line 461 | Line 570 | public class ConcurrentHashMapV8<K, V>
570      private transient volatile int sizeCtl;
571  
572      // views
573 <    private transient KeySet<K,V> keySet;
574 <    private transient Values<K,V> values;
575 <    private transient EntrySet<K,V> entrySet;
573 >    private transient KeySetView<K,V> keySet;
574 >    private transient ValuesView<K,V> values;
575 >    private transient EntrySetView<K,V> entrySet;
576  
577      /** For serialization compatibility. Null unless serialized; see below */
578      private Segment<K,V>[] segments;
# Line 2243 | Line 2352 | public class ConcurrentHashMapV8<K, V>
2352       * change (including to null, indicating deletion), field nextVal
2353       * might not be accurate at point of use, but still maintains the
2354       * weak consistency property of holding a value that was once
2355 <     * valid.
2355 >     * valid. To support iterator.remove, the nextKey field is not
2356 >     * updated (nulled out) when the iterator cannot advance.
2357       *
2358       * Internal traversals directly access these fields, as in:
2359       * {@code while (it.advance() != null) { process(it.nextKey); }}
# Line 2280 | Line 2390 | public class ConcurrentHashMapV8<K, V>
2390      @SuppressWarnings("serial") static class Traverser<K,V,R> extends ForkJoinTask<R> {
2391          final ConcurrentHashMapV8<K, V> map;
2392          Node next;           // the next entry to use
2283 –        Node last;           // the last entry used
2393          Object nextKey;      // cached key field of next
2394          Object nextVal;      // cached val field of next
2395          Node[] tab;          // current table; updated if resized
2396          int index;           // index of bin to use next
2397          int baseIndex;       // current index of initial table
2398          int baseLimit;       // index bound for initial table
2399 <        final int baseSize;  // initial table size
2399 >        int baseSize;        // initial table size
2400  
2401          /** Creates iterator for all entries in the table. */
2402          Traverser(ConcurrentHashMapV8<K, V> map) {
2403 <            this.tab = (this.map = map).table;
2295 <            baseLimit = baseSize = (tab == null) ? 0 : tab.length;
2403 >            this.map = map;
2404          }
2405  
2406          /** Creates iterator for split() methods */
2407          Traverser(Traverser<K,V,?> it) {
2408 <            this.map = it.map;
2409 <            this.tab = it.tab;
2408 >            ConcurrentHashMapV8<K, V> m; Node[] t;
2409 >            if ((m = this.map = it.map) == null)
2410 >                t = null;
2411 >            else if ((t = it.tab) == null && // force parent tab initialization
2412 >                     (t = it.tab = m.table) != null)
2413 >                it.baseLimit = it.baseSize = t.length;
2414 >            this.tab = t;
2415              this.baseSize = it.baseSize;
2416              it.baseLimit = this.index = this.baseIndex =
2417                  ((this.baseLimit = it.baseLimit) + it.baseIndex + 1) >>> 1;
# Line 2309 | Line 2422 | public class ConcurrentHashMapV8<K, V>
2422           * See above for explanation.
2423           */
2424          final Object advance() {
2425 <            Node e = last = next;
2425 >            Node e = next;
2426              Object ev = null;
2427              outer: do {
2428                  if (e != null)                  // advance past used/skipped node
2429                      e = e.next;
2430                  while (e == null) {             // get to next non-null bin
2431 +                    ConcurrentHashMapV8<K, V> m;
2432                      Node[] t; int b, i, n; Object ek; // checks must use locals
2433 <                    if ((b = baseIndex) >= baseLimit || (i = index) < 0 ||
2434 <                        (t = tab) == null || i >= (n = t.length))
2433 >                    if ((t = tab) != null)
2434 >                        n = t.length;
2435 >                    else if ((m = map) != null && (t = tab = m.table) != null)
2436 >                        n = baseLimit = baseSize = t.length;
2437 >                    else
2438                          break outer;
2439 <                    else if ((e = tabAt(t, i)) != null && e.hash == MOVED) {
2439 >                    if ((b = baseIndex) >= baseLimit ||
2440 >                        (i = index) < 0 || i >= n)
2441 >                        break outer;
2442 >                    if ((e = tabAt(t, i)) != null && e.hash == MOVED) {
2443                          if ((ek = e.key) instanceof TreeBin)
2444                              e = ((TreeBin)ek).first;
2445                          else {
# Line 2336 | Line 2456 | public class ConcurrentHashMapV8<K, V>
2456          }
2457  
2458          public final void remove() {
2459 <            if (nextVal == null && last == null)
2460 <                advance();
2341 <            Node e = last;
2342 <            if (e == null)
2459 >            Object k = nextKey;
2460 >            if (k == null && (advance() == null || (k = nextKey) == null))
2461                  throw new IllegalStateException();
2462 <            last = null;
2345 <            map.remove(e.key);
2462 >            map.internalReplace(k, null, null);
2463          }
2464  
2465          public final boolean hasNext() {
# Line 2446 | Line 2563 | public class ConcurrentHashMapV8<K, V>
2563      }
2564  
2565      /**
2566 +     * Creates a new {@link Set} backed by a ConcurrentHashMapV8
2567 +     * from the given type to {@code Boolean.TRUE}.
2568 +     *
2569 +     * @return the new set
2570 +     */
2571 +    public static <K> KeySetView<K,Boolean> newKeySet() {
2572 +        return new KeySetView<K,Boolean>(new ConcurrentHashMapV8<K,Boolean>(),
2573 +                                      Boolean.TRUE);
2574 +    }
2575 +
2576 +    /**
2577 +     * Creates a new {@link Set} backed by a ConcurrentHashMapV8
2578 +     * from the given type to {@code Boolean.TRUE}.
2579 +     *
2580 +     * @param initialCapacity The implementation performs internal
2581 +     * sizing to accommodate this many elements.
2582 +     * @throws IllegalArgumentException if the initial capacity of
2583 +     * elements is negative
2584 +     * @return the new set
2585 +     */
2586 +    public static <K> KeySetView<K,Boolean> newKeySet(int initialCapacity) {
2587 +        return new KeySetView<K,Boolean>(new ConcurrentHashMapV8<K,Boolean>(initialCapacity),
2588 +                                      Boolean.TRUE);
2589 +    }
2590 +
2591 +    /**
2592       * {@inheritDoc}
2593       */
2594      public boolean isEmpty() {
# Line 2464 | Line 2607 | public class ConcurrentHashMapV8<K, V>
2607  
2608      /**
2609       * Returns the number of mappings. This method should be used
2610 <     * instead of {@link #size} because a ConcurrentHashMap may
2610 >     * instead of {@link #size} because a ConcurrentHashMapV8 may
2611       * contain more mappings than can be represented as an int. The
2612       * value returned is a snapshot; the actual count may differ if
2613       * there are ongoing concurrent insertions or removals.
# Line 2494 | Line 2637 | public class ConcurrentHashMapV8<K, V>
2637      }
2638  
2639      /**
2640 +     * Returns the value to which the specified key is mapped,
2641 +     * or the given defaultValue if this map contains no mapping for the key.
2642 +     *
2643 +     * @param key the key
2644 +     * @param defaultValue the value to return if this map contains
2645 +     * no mapping for the given key
2646 +     * @return the mapping for the key, if present; else the defaultValue
2647 +     * @throws NullPointerException if the specified key is null
2648 +     */
2649 +    @SuppressWarnings("unchecked") public V getValueOrDefault(Object key, V defaultValue) {
2650 +        if (key == null)
2651 +            throw new NullPointerException();
2652 +        V v = (V) internalGet(key);
2653 +        return v == null ? defaultValue : v;
2654 +    }
2655 +
2656 +    /**
2657       * Tests if the specified object is a key in this table.
2658       *
2659       * @param  key   possible key
# Line 2553 | Line 2713 | public class ConcurrentHashMapV8<K, V>
2713       * Maps the specified key to the specified value in this table.
2714       * Neither the key nor the value can be null.
2715       *
2716 <     * <p> The value can be retrieved by calling the {@code get} method
2716 >     * <p>The value can be retrieved by calling the {@code get} method
2717       * with a key that is equal to the original key.
2718       *
2719       * @param key key with which the specified value is to be associated
# Line 2622 | Line 2782 | public class ConcurrentHashMapV8<K, V>
2782       * @param key key with which the specified value is to be associated
2783       * @param mappingFunction the function to compute a value
2784       * @return the current (existing or computed) value associated with
2785 <     *         the specified key, or null if the computed value is null.
2785 >     *         the specified key, or null if the computed value is null
2786       * @throws NullPointerException if the specified key or mappingFunction
2787       *         is null
2788       * @throws IllegalStateException if the computation detectably
# Line 2820 | Line 2980 | public class ConcurrentHashMapV8<K, V>
2980      /**
2981       * Returns a {@link Set} view of the keys contained in this map.
2982       * The set is backed by the map, so changes to the map are
2983 <     * reflected in the set, and vice-versa.  The set supports element
2824 <     * removal, which removes the corresponding mapping from this map,
2825 <     * via the {@code Iterator.remove}, {@code Set.remove},
2826 <     * {@code removeAll}, {@code retainAll}, and {@code clear}
2827 <     * operations.  It does not support the {@code add} or
2828 <     * {@code addAll} operations.
2983 >     * reflected in the set, and vice-versa.
2984       *
2985 <     * <p>The view's {@code iterator} is a "weakly consistent" iterator
2986 <     * that will never throw {@link ConcurrentModificationException},
2987 <     * and guarantees to traverse elements as they existed upon
2988 <     * construction of the iterator, and may (but is not guaranteed to)
2989 <     * reflect any modifications subsequent to construction.
2985 >     * @return the set view
2986 >     */
2987 >    public KeySetView<K,V> keySet() {
2988 >        KeySetView<K,V> ks = keySet;
2989 >        return (ks != null) ? ks : (keySet = new KeySetView<K,V>(this, null));
2990 >    }
2991 >
2992 >    /**
2993 >     * Returns a {@link Set} view of the keys in this map, using the
2994 >     * given common mapped value for any additions (i.e., {@link
2995 >     * Collection#add} and {@link Collection#addAll}). This is of
2996 >     * course only appropriate if it is acceptable to use the same
2997 >     * value for all additions from this view.
2998 >     *
2999 >     * @param mappedValue the mapped value to use for any
3000 >     * additions.
3001 >     * @return the set view
3002 >     * @throws NullPointerException if the mappedValue is null
3003       */
3004 <    public Set<K> keySet() {
3005 <        KeySet<K,V> ks = keySet;
3006 <        return (ks != null) ? ks : (keySet = new KeySet<K,V>(this));
3004 >    public KeySetView<K,V> keySet(V mappedValue) {
3005 >        if (mappedValue == null)
3006 >            throw new NullPointerException();
3007 >        return new KeySetView<K,V>(this, mappedValue);
3008      }
3009  
3010      /**
3011       * Returns a {@link Collection} view of the values contained in this map.
3012       * The collection is backed by the map, so changes to the map are
3013 <     * reflected in the collection, and vice-versa.  The collection
2845 <     * supports element removal, which removes the corresponding
2846 <     * mapping from this map, via the {@code Iterator.remove},
2847 <     * {@code Collection.remove}, {@code removeAll},
2848 <     * {@code retainAll}, and {@code clear} operations.  It does not
2849 <     * support the {@code add} or {@code addAll} operations.
2850 <     *
2851 <     * <p>The view's {@code iterator} is a "weakly consistent" iterator
2852 <     * that will never throw {@link ConcurrentModificationException},
2853 <     * and guarantees to traverse elements as they existed upon
2854 <     * construction of the iterator, and may (but is not guaranteed to)
2855 <     * reflect any modifications subsequent to construction.
3013 >     * reflected in the collection, and vice-versa.
3014       */
3015 <    public Collection<V> values() {
3016 <        Values<K,V> vs = values;
3017 <        return (vs != null) ? vs : (values = new Values<K,V>(this));
3015 >    public ValuesView<K,V> values() {
3016 >        ValuesView<K,V> vs = values;
3017 >        return (vs != null) ? vs : (values = new ValuesView<K,V>(this));
3018      }
3019  
3020      /**
# Line 2876 | Line 3034 | public class ConcurrentHashMapV8<K, V>
3034       * reflect any modifications subsequent to construction.
3035       */
3036      public Set<Map.Entry<K,V>> entrySet() {
3037 <        EntrySet<K,V> es = entrySet;
3038 <        return (es != null) ? es : (entrySet = new EntrySet<K,V>(this));
3037 >        EntrySetView<K,V> es = entrySet;
3038 >        return (es != null) ? es : (entrySet = new EntrySetView<K,V>(this));
3039      }
3040  
3041      /**
# Line 3017 | Line 3175 | public class ConcurrentHashMapV8<K, V>
3175              super(it);
3176          }
3177          public KeyIterator<K,V> split() {
3178 <            if (last != null || (next != null && nextVal == null))
3178 >            if (nextKey != null)
3179                  throw new IllegalStateException();
3180              return new KeyIterator<K,V>(this);
3181          }
# Line 3039 | Line 3197 | public class ConcurrentHashMapV8<K, V>
3197              super(it);
3198          }
3199          public ValueIterator<K,V> split() {
3200 <            if (last != null || (next != null && nextVal == null))
3200 >            if (nextKey != null)
3201                  throw new IllegalStateException();
3202              return new ValueIterator<K,V>(this);
3203          }
# Line 3062 | Line 3220 | public class ConcurrentHashMapV8<K, V>
3220              super(it);
3221          }
3222          public EntryIterator<K,V> split() {
3223 <            if (last != null || (next != null && nextVal == null))
3223 >            if (nextKey != null)
3224                  throw new IllegalStateException();
3225              return new EntryIterator<K,V>(this);
3226          }
# Line 3120 | Line 3278 | public class ConcurrentHashMapV8<K, V>
3278          }
3279      }
3280  
3123 –    /* ----------------Views -------------- */
3124 –
3125 –    /**
3126 –     * Base class for views.
3127 –     */
3128 –    static abstract class CHMView<K, V> {
3129 –        final ConcurrentHashMapV8<K, V> map;
3130 –        CHMView(ConcurrentHashMapV8<K, V> map)  { this.map = map; }
3131 –        public final int size()                 { return map.size(); }
3132 –        public final boolean isEmpty()          { return map.isEmpty(); }
3133 –        public final void clear()               { map.clear(); }
3134 –
3135 –        // implementations below rely on concrete classes supplying these
3136 –        abstract public Iterator<?> iterator();
3137 –        abstract public boolean contains(Object o);
3138 –        abstract public boolean remove(Object o);
3139 –
3140 –        private static final String oomeMsg = "Required array size too large";
3141 –
3142 –        public final Object[] toArray() {
3143 –            long sz = map.mappingCount();
3144 –            if (sz > (long)(MAX_ARRAY_SIZE))
3145 –                throw new OutOfMemoryError(oomeMsg);
3146 –            int n = (int)sz;
3147 –            Object[] r = new Object[n];
3148 –            int i = 0;
3149 –            Iterator<?> it = iterator();
3150 –            while (it.hasNext()) {
3151 –                if (i == n) {
3152 –                    if (n >= MAX_ARRAY_SIZE)
3153 –                        throw new OutOfMemoryError(oomeMsg);
3154 –                    if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
3155 –                        n = MAX_ARRAY_SIZE;
3156 –                    else
3157 –                        n += (n >>> 1) + 1;
3158 –                    r = Arrays.copyOf(r, n);
3159 –                }
3160 –                r[i++] = it.next();
3161 –            }
3162 –            return (i == n) ? r : Arrays.copyOf(r, i);
3163 –        }
3164 –
3165 –        @SuppressWarnings("unchecked") public final <T> T[] toArray(T[] a) {
3166 –            long sz = map.mappingCount();
3167 –            if (sz > (long)(MAX_ARRAY_SIZE))
3168 –                throw new OutOfMemoryError(oomeMsg);
3169 –            int m = (int)sz;
3170 –            T[] r = (a.length >= m) ? a :
3171 –                (T[])java.lang.reflect.Array
3172 –                .newInstance(a.getClass().getComponentType(), m);
3173 –            int n = r.length;
3174 –            int i = 0;
3175 –            Iterator<?> it = iterator();
3176 –            while (it.hasNext()) {
3177 –                if (i == n) {
3178 –                    if (n >= MAX_ARRAY_SIZE)
3179 –                        throw new OutOfMemoryError(oomeMsg);
3180 –                    if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
3181 –                        n = MAX_ARRAY_SIZE;
3182 –                    else
3183 –                        n += (n >>> 1) + 1;
3184 –                    r = Arrays.copyOf(r, n);
3185 –                }
3186 –                r[i++] = (T)it.next();
3187 –            }
3188 –            if (a == r && i < n) {
3189 –                r[i] = null; // null-terminate
3190 –                return r;
3191 –            }
3192 –            return (i == n) ? r : Arrays.copyOf(r, i);
3193 –        }
3194 –
3195 –        public final int hashCode() {
3196 –            int h = 0;
3197 –            for (Iterator<?> it = iterator(); it.hasNext();)
3198 –                h += it.next().hashCode();
3199 –            return h;
3200 –        }
3201 –
3202 –        public final String toString() {
3203 –            StringBuilder sb = new StringBuilder();
3204 –            sb.append('[');
3205 –            Iterator<?> it = iterator();
3206 –            if (it.hasNext()) {
3207 –                for (;;) {
3208 –                    Object e = it.next();
3209 –                    sb.append(e == this ? "(this Collection)" : e);
3210 –                    if (!it.hasNext())
3211 –                        break;
3212 –                    sb.append(',').append(' ');
3213 –                }
3214 –            }
3215 –            return sb.append(']').toString();
3216 –        }
3217 –
3218 –        public final boolean containsAll(Collection<?> c) {
3219 –            if (c != this) {
3220 –                for (Iterator<?> it = c.iterator(); it.hasNext();) {
3221 –                    Object e = it.next();
3222 –                    if (e == null || !contains(e))
3223 –                        return false;
3224 –                }
3225 –            }
3226 –            return true;
3227 –        }
3228 –
3229 –        public final boolean removeAll(Collection<?> c) {
3230 –            boolean modified = false;
3231 –            for (Iterator<?> it = iterator(); it.hasNext();) {
3232 –                if (c.contains(it.next())) {
3233 –                    it.remove();
3234 –                    modified = true;
3235 –                }
3236 –            }
3237 –            return modified;
3238 –        }
3239 –
3240 –        public final boolean retainAll(Collection<?> c) {
3241 –            boolean modified = false;
3242 –            for (Iterator<?> it = iterator(); it.hasNext();) {
3243 –                if (!c.contains(it.next())) {
3244 –                    it.remove();
3245 –                    modified = true;
3246 –                }
3247 –            }
3248 –            return modified;
3249 –        }
3250 –
3251 –    }
3252 –
3253 –    static final class KeySet<K,V> extends CHMView<K,V> implements Set<K> {
3254 –        KeySet(ConcurrentHashMapV8<K, V> map)  {
3255 –            super(map);
3256 –        }
3257 –        public final boolean contains(Object o) { return map.containsKey(o); }
3258 –        public final boolean remove(Object o)   { return map.remove(o) != null; }
3259 –        public final Iterator<K> iterator() {
3260 –            return new KeyIterator<K,V>(map);
3261 –        }
3262 –        public final boolean add(K e) {
3263 –            throw new UnsupportedOperationException();
3264 –        }
3265 –        public final boolean addAll(Collection<? extends K> c) {
3266 –            throw new UnsupportedOperationException();
3267 –        }
3268 –        public boolean equals(Object o) {
3269 –            Set<?> c;
3270 –            return ((o instanceof Set) &&
3271 –                    ((c = (Set<?>)o) == this ||
3272 –                     (containsAll(c) && c.containsAll(this))));
3273 –        }
3274 –    }
3275 –
3276 –
3277 –    static final class Values<K,V> extends CHMView<K,V>
3278 –        implements Collection<V> {
3279 –        Values(ConcurrentHashMapV8<K, V> map)   { super(map); }
3280 –        public final boolean contains(Object o) { return map.containsValue(o); }
3281 –        public final boolean remove(Object o) {
3282 –            if (o != null) {
3283 –                Iterator<V> it = new ValueIterator<K,V>(map);
3284 –                while (it.hasNext()) {
3285 –                    if (o.equals(it.next())) {
3286 –                        it.remove();
3287 –                        return true;
3288 –                    }
3289 –                }
3290 –            }
3291 –            return false;
3292 –        }
3293 –        public final Iterator<V> iterator() {
3294 –            return new ValueIterator<K,V>(map);
3295 –        }
3296 –        public final boolean add(V e) {
3297 –            throw new UnsupportedOperationException();
3298 –        }
3299 –        public final boolean addAll(Collection<? extends V> c) {
3300 –            throw new UnsupportedOperationException();
3301 –        }
3302 –
3303 –    }
3304 –
3305 –    static final class EntrySet<K,V> extends CHMView<K,V>
3306 –        implements Set<Map.Entry<K,V>> {
3307 –        EntrySet(ConcurrentHashMapV8<K, V> map) { super(map); }
3308 –        public final boolean contains(Object o) {
3309 –            Object k, v, r; Map.Entry<?,?> e;
3310 –            return ((o instanceof Map.Entry) &&
3311 –                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
3312 –                    (r = map.get(k)) != null &&
3313 –                    (v = e.getValue()) != null &&
3314 –                    (v == r || v.equals(r)));
3315 –        }
3316 –        public final boolean remove(Object o) {
3317 –            Object k, v; Map.Entry<?,?> e;
3318 –            return ((o instanceof Map.Entry) &&
3319 –                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
3320 –                    (v = e.getValue()) != null &&
3321 –                    map.remove(k, v));
3322 –        }
3323 –        public final Iterator<Map.Entry<K,V>> iterator() {
3324 –            return new EntryIterator<K,V>(map);
3325 –        }
3326 –        public final boolean add(Entry<K,V> e) {
3327 –            throw new UnsupportedOperationException();
3328 –        }
3329 –        public final boolean addAll(Collection<? extends Entry<K,V>> c) {
3330 –            throw new UnsupportedOperationException();
3331 –        }
3332 –        public boolean equals(Object o) {
3333 –            Set<?> c;
3334 –            return ((o instanceof Set) &&
3335 –                    ((c = (Set<?>)o) == this ||
3336 –                     (containsAll(c) && c.containsAll(this))));
3337 –        }
3338 –    }
3339 –
3281      /* ---------------- Serialization Support -------------- */
3282  
3283      /**
# Line 3503 | Line 3444 | public class ConcurrentHashMapV8<K, V>
3444      // -------------------------------------------------------
3445  
3446      /**
3447 <     * Returns an extended {@link Parallel} view of this map using the
3507 <     * given executor for bulk parallel operations.
3447 >     * Performs the given action for each (key, value).
3448       *
3449 <     * @param executor the executor
3510 <     * @return a parallel view
3449 >     * @param action the action
3450       */
3451 <    public Parallel parallel(ForkJoinPool executor)  {
3452 <        return new Parallel(executor);
3451 >    public void forEach(BiAction<K,V> action) {
3452 >        ForkJoinTasks.forEach
3453 >            (this, action).invoke();
3454      }
3455  
3456      /**
3457 <     * An extended view of a ConcurrentHashMap supporting bulk
3458 <     * parallel operations. These operations are designed to be
3459 <     * safely, and often sensibly, applied even with maps that are
3460 <     * being concurrently updated by other threads; for example, when
3461 <     * computing a snapshot summary of the values in a shared
3462 <     * registry.  There are three kinds of operation, each with four
3463 <     * forms, accepting functions with Keys, Values, Entries, and
3464 <     * (Key, Value) arguments and/or return values. Because the
3465 <     * elements of a ConcurrentHashMap are not ordered in any
3466 <     * particular way, and may be processed in different orders in
3467 <     * different parallel executions, the correctness of supplied
3468 <     * functions should not depend on any ordering, or on any other
3469 <     * objects or values that may transiently change while computation
3470 <     * is in progress; and except for forEach actions, should ideally
3471 <     * be side-effect-free.
3472 <     *
3473 <     * <ul>
3474 <     * <li> forEach: Perform a given action on each element.
3475 <     * A variant form applies a given transformation on each element
3476 <     * before performing the action.</li>
3477 <     *
3478 <     * <li> search: Return the first available non-null result of
3479 <     * applying a given function on each element; skipping further
3480 <     * search when a result is found.</li>
3481 <     *
3482 <     * <li> reduce: Accumulate each element.  The supplied reduction
3483 <     * function cannot rely on ordering (more formally, it should be
3484 <     * both associative and commutative).  There are five variants:
3485 <     *
3486 <     * <ul>
3487 <     *
3488 <     * <li> Plain reductions. (There is not a form of this method for
3489 <     * (key, value) function arguments since there is no corresponding
3490 <     * return type.)</li>
3491 <     *
3492 <     * <li> Mapped reductions that accumulate the results of a given
3493 <     * function applied to each element.</li>
3494 <     *
3495 <     * <li> Reductions to scalar doubles, longs, and ints, using a
3496 <     * given basis value.</li>
3497 <     *
3498 <     * </li>
3499 <     * </ul>
3500 <     * </ul>
3501 <     *
3502 <     * <p>The concurrency properties of the bulk operations follow
3503 <     * from those of ConcurrentHashMap: Any non-null result returned
3504 <     * from {@code get(key)} and related access methods bears a
3505 <     * happens-before relation with the associated insertion or
3506 <     * update.  The result of any bulk operation reflects the
3507 <     * composition of these per-element relations (but is not
3508 <     * necessarily atomic with respect to the map as a whole unless it
3509 <     * is somehow known to be quiescent).  Conversely, because keys
3510 <     * and values in the map are never null, null serves as a reliable
3511 <     * atomic indicator of the current lack of any result.  To
3512 <     * maintain this property, null serves as an implicit basis for
3513 <     * all non-scalar reduction operations. For the double, long, and
3514 <     * int versions, the basis should be one that, when combined with
3515 <     * any other value, returns that other value (more formally, it
3516 <     * should be the identity element for the reduction). Most common
3517 <     * reductions have these properties; for example, computing a sum
3518 <     * with basis 0 or a minimum with basis MAX_VALUE.
3519 <     *
3520 <     * <p>Search and transformation functions provided as arguments
3521 <     * should similarly return null to indicate the lack of any result
3522 <     * (in which case it is not used). In the case of mapped
3523 <     * reductions, this also enables transformations to serve as
3524 <     * filters, returning null (or, in the case of primitive
3525 <     * specializations, the identity basis) if the element should not
3526 <     * be combined. You can create compound transformations and
3527 <     * filterings by composing them yourself under this "null means
3528 <     * there is nothing there now" rule before using them in search or
3529 <     * reduce operations.
3530 <     *
3531 <     * <p>Methods accepting and/or returning Entry arguments maintain
3532 <     * key-value associations. They may be useful for example when
3533 <     * finding the key for the greatest value. Note that "plain" Entry
3534 <     * arguments can be supplied using {@code new
3535 <     * AbstractMap.SimpleEntry(k,v)}.
3536 <     *
3537 <     * <p> Bulk operations may complete abruptly, throwing an
3538 <     * exception encountered in the application of a supplied
3539 <     * function. Bear in mind when handling such exceptions that other
3540 <     * concurrently executing functions could also have thrown
3541 <     * exceptions, or would have done so if the first exception had
3542 <     * not occurred.
3543 <     *
3544 <     * <p>Parallel speedups compared to sequential processing are
3545 <     * common but not guaranteed.  Operations involving brief
3546 <     * functions on small maps may execute more slowly than sequential
3547 <     * loops if the underlying work to parallelize the computation is
3548 <     * more expensive than the computation itself. Similarly,
3549 <     * parallelization may not lead to much actual parallelism if all
3550 <     * processors are busy performing unrelated tasks.
3551 <     *
3552 <     * <p> All arguments to all task methods must be non-null.
3553 <     *
3554 <     * <p><em>jsr166e note: During transition, this class
3555 <     * uses nested functional interfaces with different names but the
3556 <     * same forms as those expected for JDK8.<em>
3557 <     */
3558 <    public class Parallel {
3559 <        final ForkJoinPool fjp;
3560 <
3561 <        /**
3562 <         * Returns an extended view of this map using the given
3563 <         * executor for bulk parallel operations.
3564 <         *
3565 <         * @param executor the executor
3566 <         */
3567 <        public Parallel(ForkJoinPool executor)  {
3568 <            this.fjp = executor;
3569 <        }
3457 >     * Performs the given action for each non-null transformation
3458 >     * of each (key, value).
3459 >     *
3460 >     * @param transformer a function returning the transformation
3461 >     * for an element, or null of there is no transformation (in
3462 >     * which case the action is not applied).
3463 >     * @param action the action
3464 >     */
3465 >    public <U> void forEach(BiFun<? super K, ? super V, ? extends U> transformer,
3466 >                            Action<U> action) {
3467 >        ForkJoinTasks.forEach
3468 >            (this, transformer, action).invoke();
3469 >    }
3470 >
3471 >    /**
3472 >     * Returns a non-null result from applying the given search
3473 >     * function on each (key, value), or null if none.  Upon
3474 >     * success, further element processing is suppressed and the
3475 >     * results of any other parallel invocations of the search
3476 >     * function are ignored.
3477 >     *
3478 >     * @param searchFunction a function returning a non-null
3479 >     * result on success, else null
3480 >     * @return a non-null result from applying the given search
3481 >     * function on each (key, value), or null if none
3482 >     */
3483 >    public <U> U search(BiFun<? super K, ? super V, ? extends U> searchFunction) {
3484 >        return ForkJoinTasks.search
3485 >            (this, searchFunction).invoke();
3486 >    }
3487 >
3488 >    /**
3489 >     * Returns the result of accumulating the given transformation
3490 >     * of all (key, value) pairs using the given reducer to
3491 >     * combine values, or null if none.
3492 >     *
3493 >     * @param transformer a function returning the transformation
3494 >     * for an element, or null of there is no transformation (in
3495 >     * which case it is not combined).
3496 >     * @param reducer a commutative associative combining function
3497 >     * @return the result of accumulating the given transformation
3498 >     * of all (key, value) pairs
3499 >     */
3500 >    public <U> U reduce(BiFun<? super K, ? super V, ? extends U> transformer,
3501 >                        BiFun<? super U, ? super U, ? extends U> reducer) {
3502 >        return ForkJoinTasks.reduce
3503 >            (this, transformer, reducer).invoke();
3504 >    }
3505 >
3506 >    /**
3507 >     * Returns the result of accumulating the given transformation
3508 >     * of all (key, value) pairs using the given reducer to
3509 >     * combine values, and the given basis as an identity value.
3510 >     *
3511 >     * @param transformer a function returning the transformation
3512 >     * for an element
3513 >     * @param basis the identity (initial default value) for the reduction
3514 >     * @param reducer a commutative associative combining function
3515 >     * @return the result of accumulating the given transformation
3516 >     * of all (key, value) pairs
3517 >     */
3518 >    public double reduceToDouble(ObjectByObjectToDouble<? super K, ? super V> transformer,
3519 >                                 double basis,
3520 >                                 DoubleByDoubleToDouble reducer) {
3521 >        return ForkJoinTasks.reduceToDouble
3522 >            (this, transformer, basis, reducer).invoke();
3523 >    }
3524 >
3525 >    /**
3526 >     * Returns the result of accumulating the given transformation
3527 >     * of all (key, value) pairs using the given reducer to
3528 >     * combine values, and the given basis as an identity value.
3529 >     *
3530 >     * @param transformer a function returning the transformation
3531 >     * for an element
3532 >     * @param basis the identity (initial default value) for the reduction
3533 >     * @param reducer a commutative associative combining function
3534 >     * @return the result of accumulating the given transformation
3535 >     * of all (key, value) pairs
3536 >     */
3537 >    public long reduceToLong(ObjectByObjectToLong<? super K, ? super V> transformer,
3538 >                             long basis,
3539 >                             LongByLongToLong reducer) {
3540 >        return ForkJoinTasks.reduceToLong
3541 >            (this, transformer, basis, reducer).invoke();
3542 >    }
3543 >
3544 >    /**
3545 >     * Returns the result of accumulating the given transformation
3546 >     * of all (key, value) pairs using the given reducer to
3547 >     * combine values, and the given basis as an identity value.
3548 >     *
3549 >     * @param transformer a function returning the transformation
3550 >     * for an element
3551 >     * @param basis the identity (initial default value) for the reduction
3552 >     * @param reducer a commutative associative combining function
3553 >     * @return the result of accumulating the given transformation
3554 >     * of all (key, value) pairs
3555 >     */
3556 >    public int reduceToInt(ObjectByObjectToInt<? super K, ? super V> transformer,
3557 >                           int basis,
3558 >                           IntByIntToInt reducer) {
3559 >        return ForkJoinTasks.reduceToInt
3560 >            (this, transformer, basis, reducer).invoke();
3561 >    }
3562 >
3563 >    /**
3564 >     * Performs the given action for each key.
3565 >     *
3566 >     * @param action the action
3567 >     */
3568 >    public void forEachKey(Action<K> action) {
3569 >        ForkJoinTasks.forEachKey
3570 >            (this, action).invoke();
3571 >    }
3572 >
3573 >    /**
3574 >     * Performs the given action for each non-null transformation
3575 >     * of each key.
3576 >     *
3577 >     * @param transformer a function returning the transformation
3578 >     * for an element, or null of there is no transformation (in
3579 >     * which case the action is not applied).
3580 >     * @param action the action
3581 >     */
3582 >    public <U> void forEachKey(Fun<? super K, ? extends U> transformer,
3583 >                               Action<U> action) {
3584 >        ForkJoinTasks.forEachKey
3585 >            (this, transformer, action).invoke();
3586 >    }
3587 >
3588 >    /**
3589 >     * Returns a non-null result from applying the given search
3590 >     * function on each key, or null if none. Upon success,
3591 >     * further element processing is suppressed and the results of
3592 >     * any other parallel invocations of the search function are
3593 >     * ignored.
3594 >     *
3595 >     * @param searchFunction a function returning a non-null
3596 >     * result on success, else null
3597 >     * @return a non-null result from applying the given search
3598 >     * function on each key, or null if none
3599 >     */
3600 >    public <U> U searchKeys(Fun<? super K, ? extends U> searchFunction) {
3601 >        return ForkJoinTasks.searchKeys
3602 >            (this, searchFunction).invoke();
3603 >    }
3604 >
3605 >    /**
3606 >     * Returns the result of accumulating all keys using the given
3607 >     * reducer to combine values, or null if none.
3608 >     *
3609 >     * @param reducer a commutative associative combining function
3610 >     * @return the result of accumulating all keys using the given
3611 >     * reducer to combine values, or null if none
3612 >     */
3613 >    public K reduceKeys(BiFun<? super K, ? super K, ? extends K> reducer) {
3614 >        return ForkJoinTasks.reduceKeys
3615 >            (this, reducer).invoke();
3616 >    }
3617 >
3618 >    /**
3619 >     * Returns the result of accumulating the given transformation
3620 >     * of all keys using the given reducer to combine values, or
3621 >     * null if none.
3622 >     *
3623 >     * @param transformer a function returning the transformation
3624 >     * for an element, or null of there is no transformation (in
3625 >     * which case it is not combined).
3626 >     * @param reducer a commutative associative combining function
3627 >     * @return the result of accumulating the given transformation
3628 >     * of all keys
3629 >     */
3630 >    public <U> U reduceKeys(Fun<? super K, ? extends U> transformer,
3631 >                            BiFun<? super U, ? super U, ? extends U> reducer) {
3632 >        return ForkJoinTasks.reduceKeys
3633 >            (this, transformer, reducer).invoke();
3634 >    }
3635 >
3636 >    /**
3637 >     * Returns the result of accumulating the given transformation
3638 >     * of all keys using the given reducer to combine values, and
3639 >     * the given basis as an identity value.
3640 >     *
3641 >     * @param transformer a function returning the transformation
3642 >     * for an element
3643 >     * @param basis the identity (initial default value) for the reduction
3644 >     * @param reducer a commutative associative combining function
3645 >     * @return  the result of accumulating the given transformation
3646 >     * of all keys
3647 >     */
3648 >    public double reduceKeysToDouble(ObjectToDouble<? super K> transformer,
3649 >                                     double basis,
3650 >                                     DoubleByDoubleToDouble reducer) {
3651 >        return ForkJoinTasks.reduceKeysToDouble
3652 >            (this, transformer, basis, reducer).invoke();
3653 >    }
3654 >
3655 >    /**
3656 >     * Returns the result of accumulating the given transformation
3657 >     * of all keys using the given reducer to combine values, and
3658 >     * the given basis as an identity value.
3659 >     *
3660 >     * @param transformer a function returning the transformation
3661 >     * for an element
3662 >     * @param basis the identity (initial default value) for the reduction
3663 >     * @param reducer a commutative associative combining function
3664 >     * @return the result of accumulating the given transformation
3665 >     * of all keys
3666 >     */
3667 >    public long reduceKeysToLong(ObjectToLong<? super K> transformer,
3668 >                                 long basis,
3669 >                                 LongByLongToLong reducer) {
3670 >        return ForkJoinTasks.reduceKeysToLong
3671 >            (this, transformer, basis, reducer).invoke();
3672 >    }
3673 >
3674 >    /**
3675 >     * Returns the result of accumulating the given transformation
3676 >     * of all keys using the given reducer to combine values, and
3677 >     * the given basis as an identity value.
3678 >     *
3679 >     * @param transformer a function returning the transformation
3680 >     * for an element
3681 >     * @param basis the identity (initial default value) for the reduction
3682 >     * @param reducer a commutative associative combining function
3683 >     * @return the result of accumulating the given transformation
3684 >     * of all keys
3685 >     */
3686 >    public int reduceKeysToInt(ObjectToInt<? super K> transformer,
3687 >                               int basis,
3688 >                               IntByIntToInt reducer) {
3689 >        return ForkJoinTasks.reduceKeysToInt
3690 >            (this, transformer, basis, reducer).invoke();
3691 >    }
3692 >
3693 >    /**
3694 >     * Performs the given action for each value.
3695 >     *
3696 >     * @param action the action
3697 >     */
3698 >    public void forEachValue(Action<V> action) {
3699 >        ForkJoinTasks.forEachValue
3700 >            (this, action).invoke();
3701 >    }
3702 >
3703 >    /**
3704 >     * Performs the given action for each non-null transformation
3705 >     * of each value.
3706 >     *
3707 >     * @param transformer a function returning the transformation
3708 >     * for an element, or null of there is no transformation (in
3709 >     * which case the action is not applied).
3710 >     */
3711 >    public <U> void forEachValue(Fun<? super V, ? extends U> transformer,
3712 >                                 Action<U> action) {
3713 >        ForkJoinTasks.forEachValue
3714 >            (this, transformer, action).invoke();
3715 >    }
3716 >
3717 >    /**
3718 >     * Returns a non-null result from applying the given search
3719 >     * function on each value, or null if none.  Upon success,
3720 >     * further element processing is suppressed and the results of
3721 >     * any other parallel invocations of the search function are
3722 >     * ignored.
3723 >     *
3724 >     * @param searchFunction a function returning a non-null
3725 >     * result on success, else null
3726 >     * @return a non-null result from applying the given search
3727 >     * function on each value, or null if none
3728 >     *
3729 >     */
3730 >    public <U> U searchValues(Fun<? super V, ? extends U> searchFunction) {
3731 >        return ForkJoinTasks.searchValues
3732 >            (this, searchFunction).invoke();
3733 >    }
3734 >
3735 >    /**
3736 >     * Returns the result of accumulating all values using the
3737 >     * given reducer to combine values, or null if none.
3738 >     *
3739 >     * @param reducer a commutative associative combining function
3740 >     * @return  the result of accumulating all values
3741 >     */
3742 >    public V reduceValues(BiFun<? super V, ? super V, ? extends V> reducer) {
3743 >        return ForkJoinTasks.reduceValues
3744 >            (this, reducer).invoke();
3745 >    }
3746 >
3747 >    /**
3748 >     * Returns the result of accumulating the given transformation
3749 >     * of all values using the given reducer to combine values, or
3750 >     * null if none.
3751 >     *
3752 >     * @param transformer a function returning the transformation
3753 >     * for an element, or null of there is no transformation (in
3754 >     * which case it is not combined).
3755 >     * @param reducer a commutative associative combining function
3756 >     * @return the result of accumulating the given transformation
3757 >     * of all values
3758 >     */
3759 >    public <U> U reduceValues(Fun<? super V, ? extends U> transformer,
3760 >                              BiFun<? super U, ? super U, ? extends U> reducer) {
3761 >        return ForkJoinTasks.reduceValues
3762 >            (this, transformer, reducer).invoke();
3763 >    }
3764 >
3765 >    /**
3766 >     * Returns the result of accumulating the given transformation
3767 >     * of all values using the given reducer to combine values,
3768 >     * and the given basis as an identity value.
3769 >     *
3770 >     * @param transformer a function returning the transformation
3771 >     * for an element
3772 >     * @param basis the identity (initial default value) for the reduction
3773 >     * @param reducer a commutative associative combining function
3774 >     * @return the result of accumulating the given transformation
3775 >     * of all values
3776 >     */
3777 >    public double reduceValuesToDouble(ObjectToDouble<? super V> transformer,
3778 >                                       double basis,
3779 >                                       DoubleByDoubleToDouble reducer) {
3780 >        return ForkJoinTasks.reduceValuesToDouble
3781 >            (this, transformer, basis, reducer).invoke();
3782 >    }
3783 >
3784 >    /**
3785 >     * Returns the result of accumulating the given transformation
3786 >     * of all values using the given reducer to combine values,
3787 >     * and the given basis as an identity value.
3788 >     *
3789 >     * @param transformer a function returning the transformation
3790 >     * for an element
3791 >     * @param basis the identity (initial default value) for the reduction
3792 >     * @param reducer a commutative associative combining function
3793 >     * @return the result of accumulating the given transformation
3794 >     * of all values
3795 >     */
3796 >    public long reduceValuesToLong(ObjectToLong<? super V> transformer,
3797 >                                   long basis,
3798 >                                   LongByLongToLong reducer) {
3799 >        return ForkJoinTasks.reduceValuesToLong
3800 >            (this, transformer, basis, reducer).invoke();
3801 >    }
3802 >
3803 >    /**
3804 >     * Returns the result of accumulating the given transformation
3805 >     * of all values using the given reducer to combine values,
3806 >     * and the given basis as an identity value.
3807 >     *
3808 >     * @param transformer a function returning the transformation
3809 >     * for an element
3810 >     * @param basis the identity (initial default value) for the reduction
3811 >     * @param reducer a commutative associative combining function
3812 >     * @return the result of accumulating the given transformation
3813 >     * of all values
3814 >     */
3815 >    public int reduceValuesToInt(ObjectToInt<? super V> transformer,
3816 >                                 int basis,
3817 >                                 IntByIntToInt reducer) {
3818 >        return ForkJoinTasks.reduceValuesToInt
3819 >            (this, transformer, basis, reducer).invoke();
3820 >    }
3821 >
3822 >    /**
3823 >     * Performs the given action for each entry.
3824 >     *
3825 >     * @param action the action
3826 >     */
3827 >    public void forEachEntry(Action<Map.Entry<K,V>> action) {
3828 >        ForkJoinTasks.forEachEntry
3829 >            (this, action).invoke();
3830 >    }
3831 >
3832 >    /**
3833 >     * Performs the given action for each non-null transformation
3834 >     * of each entry.
3835 >     *
3836 >     * @param transformer a function returning the transformation
3837 >     * for an element, or null of there is no transformation (in
3838 >     * which case the action is not applied).
3839 >     * @param action the action
3840 >     */
3841 >    public <U> void forEachEntry(Fun<Map.Entry<K,V>, ? extends U> transformer,
3842 >                                 Action<U> action) {
3843 >        ForkJoinTasks.forEachEntry
3844 >            (this, transformer, action).invoke();
3845 >    }
3846 >
3847 >    /**
3848 >     * Returns a non-null result from applying the given search
3849 >     * function on each entry, or null if none.  Upon success,
3850 >     * further element processing is suppressed and the results of
3851 >     * any other parallel invocations of the search function are
3852 >     * ignored.
3853 >     *
3854 >     * @param searchFunction a function returning a non-null
3855 >     * result on success, else null
3856 >     * @return a non-null result from applying the given search
3857 >     * function on each entry, or null if none
3858 >     */
3859 >    public <U> U searchEntries(Fun<Map.Entry<K,V>, ? extends U> searchFunction) {
3860 >        return ForkJoinTasks.searchEntries
3861 >            (this, searchFunction).invoke();
3862 >    }
3863 >
3864 >    /**
3865 >     * Returns the result of accumulating all entries using the
3866 >     * given reducer to combine values, or null if none.
3867 >     *
3868 >     * @param reducer a commutative associative combining function
3869 >     * @return the result of accumulating all entries
3870 >     */
3871 >    public Map.Entry<K,V> reduceEntries(BiFun<Map.Entry<K,V>, Map.Entry<K,V>, ? extends Map.Entry<K,V>> reducer) {
3872 >        return ForkJoinTasks.reduceEntries
3873 >            (this, reducer).invoke();
3874 >    }
3875 >
3876 >    /**
3877 >     * Returns the result of accumulating the given transformation
3878 >     * of all entries using the given reducer to combine values,
3879 >     * or null if none.
3880 >     *
3881 >     * @param transformer a function returning the transformation
3882 >     * for an element, or null of there is no transformation (in
3883 >     * which case it is not combined).
3884 >     * @param reducer a commutative associative combining function
3885 >     * @return the result of accumulating the given transformation
3886 >     * of all entries
3887 >     */
3888 >    public <U> U reduceEntries(Fun<Map.Entry<K,V>, ? extends U> transformer,
3889 >                               BiFun<? super U, ? super U, ? extends U> reducer) {
3890 >        return ForkJoinTasks.reduceEntries
3891 >            (this, transformer, reducer).invoke();
3892 >    }
3893 >
3894 >    /**
3895 >     * Returns the result of accumulating the given transformation
3896 >     * of all entries using the given reducer to combine values,
3897 >     * and the given basis as an identity value.
3898 >     *
3899 >     * @param transformer a function returning the transformation
3900 >     * for an element
3901 >     * @param basis the identity (initial default value) for the reduction
3902 >     * @param reducer a commutative associative combining function
3903 >     * @return the result of accumulating the given transformation
3904 >     * of all entries
3905 >     */
3906 >    public double reduceEntriesToDouble(ObjectToDouble<Map.Entry<K,V>> transformer,
3907 >                                        double basis,
3908 >                                        DoubleByDoubleToDouble reducer) {
3909 >        return ForkJoinTasks.reduceEntriesToDouble
3910 >            (this, transformer, basis, reducer).invoke();
3911 >    }
3912 >
3913 >    /**
3914 >     * Returns the result of accumulating the given transformation
3915 >     * of all entries using the given reducer to combine values,
3916 >     * and the given basis as an identity value.
3917 >     *
3918 >     * @param transformer a function returning the transformation
3919 >     * for an element
3920 >     * @param basis the identity (initial default value) for the reduction
3921 >     * @param reducer a commutative associative combining function
3922 >     * @return  the result of accumulating the given transformation
3923 >     * of all entries
3924 >     */
3925 >    public long reduceEntriesToLong(ObjectToLong<Map.Entry<K,V>> transformer,
3926 >                                    long basis,
3927 >                                    LongByLongToLong reducer) {
3928 >        return ForkJoinTasks.reduceEntriesToLong
3929 >            (this, transformer, basis, reducer).invoke();
3930 >    }
3931 >
3932 >    /**
3933 >     * Returns the result of accumulating the given transformation
3934 >     * of all entries using the given reducer to combine values,
3935 >     * and the given basis as an identity value.
3936 >     *
3937 >     * @param transformer a function returning the transformation
3938 >     * for an element
3939 >     * @param basis the identity (initial default value) for the reduction
3940 >     * @param reducer a commutative associative combining function
3941 >     * @return the result of accumulating the given transformation
3942 >     * of all entries
3943 >     */
3944 >    public int reduceEntriesToInt(ObjectToInt<Map.Entry<K,V>> transformer,
3945 >                                  int basis,
3946 >                                  IntByIntToInt reducer) {
3947 >        return ForkJoinTasks.reduceEntriesToInt
3948 >            (this, transformer, basis, reducer).invoke();
3949 >    }
3950 >
3951 >    /* ----------------Views -------------- */
3952 >
3953 >    /**
3954 >     * Base class for views.
3955 >     */
3956 >    static abstract class CHMView<K, V> {
3957 >        final ConcurrentHashMapV8<K, V> map;
3958 >        CHMView(ConcurrentHashMapV8<K, V> map)  { this.map = map; }
3959  
3960          /**
3961 <         * Performs the given action for each (key, value).
3961 >         * Returns the map backing this view.
3962           *
3963 <         * @param action the action
3963 >         * @return the map backing this view
3964           */
3965 <        public void forEach(BiAction<K,V> action) {
3966 <            fjp.invoke(ForkJoinTasks.forEach
3967 <                       (ConcurrentHashMapV8.this, action));
3965 >        public ConcurrentHashMapV8<K,V> getMap() { return map; }
3966 >
3967 >        public final int size()                 { return map.size(); }
3968 >        public final boolean isEmpty()          { return map.isEmpty(); }
3969 >        public final void clear()               { map.clear(); }
3970 >
3971 >        // implementations below rely on concrete classes supplying these
3972 >        abstract public Iterator<?> iterator();
3973 >        abstract public boolean contains(Object o);
3974 >        abstract public boolean remove(Object o);
3975 >
3976 >        private static final String oomeMsg = "Required array size too large";
3977 >
3978 >        public final Object[] toArray() {
3979 >            long sz = map.mappingCount();
3980 >            if (sz > (long)(MAX_ARRAY_SIZE))
3981 >                throw new OutOfMemoryError(oomeMsg);
3982 >            int n = (int)sz;
3983 >            Object[] r = new Object[n];
3984 >            int i = 0;
3985 >            Iterator<?> it = iterator();
3986 >            while (it.hasNext()) {
3987 >                if (i == n) {
3988 >                    if (n >= MAX_ARRAY_SIZE)
3989 >                        throw new OutOfMemoryError(oomeMsg);
3990 >                    if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
3991 >                        n = MAX_ARRAY_SIZE;
3992 >                    else
3993 >                        n += (n >>> 1) + 1;
3994 >                    r = Arrays.copyOf(r, n);
3995 >                }
3996 >                r[i++] = it.next();
3997 >            }
3998 >            return (i == n) ? r : Arrays.copyOf(r, i);
3999          }
4000  
4001 <        /**
4002 <         * Performs the given action for each non-null transformation
4003 <         * of each (key, value).
4004 <         *
4005 <         * @param transformer a function returning the transformation
4006 <         * for an element, or null of there is no transformation (in
4007 <         * which case the action is not applied).
4008 <         * @param action the action
4009 <         */
4010 <        public <U> void forEach(BiFun<? super K, ? super V, ? extends U> transformer,
4011 <                                Action<U> action) {
4012 <            fjp.invoke(ForkJoinTasks.forEach
4013 <                       (ConcurrentHashMapV8.this, transformer, action));
4001 >        @SuppressWarnings("unchecked") public final <T> T[] toArray(T[] a) {
4002 >            long sz = map.mappingCount();
4003 >            if (sz > (long)(MAX_ARRAY_SIZE))
4004 >                throw new OutOfMemoryError(oomeMsg);
4005 >            int m = (int)sz;
4006 >            T[] r = (a.length >= m) ? a :
4007 >                (T[])java.lang.reflect.Array
4008 >                .newInstance(a.getClass().getComponentType(), m);
4009 >            int n = r.length;
4010 >            int i = 0;
4011 >            Iterator<?> it = iterator();
4012 >            while (it.hasNext()) {
4013 >                if (i == n) {
4014 >                    if (n >= MAX_ARRAY_SIZE)
4015 >                        throw new OutOfMemoryError(oomeMsg);
4016 >                    if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
4017 >                        n = MAX_ARRAY_SIZE;
4018 >                    else
4019 >                        n += (n >>> 1) + 1;
4020 >                    r = Arrays.copyOf(r, n);
4021 >                }
4022 >                r[i++] = (T)it.next();
4023 >            }
4024 >            if (a == r && i < n) {
4025 >                r[i] = null; // null-terminate
4026 >                return r;
4027 >            }
4028 >            return (i == n) ? r : Arrays.copyOf(r, i);
4029          }
4030  
4031 <        /**
4032 <         * Returns a non-null result from applying the given search
4033 <         * function on each (key, value), or null if none.  Upon
4034 <         * success, further element processing is suppressed and the
4035 <         * results of any other parallel invocations of the search
3661 <         * function are ignored.
3662 <         *
3663 <         * @param searchFunction a function returning a non-null
3664 <         * result on success, else null
3665 <         * @return a non-null result from applying the given search
3666 <         * function on each (key, value), or null if none
3667 <         */
3668 <        public <U> U search(BiFun<? super K, ? super V, ? extends U> searchFunction) {
3669 <            return fjp.invoke(ForkJoinTasks.search
3670 <                              (ConcurrentHashMapV8.this, searchFunction));
4031 >        public final int hashCode() {
4032 >            int h = 0;
4033 >            for (Iterator<?> it = iterator(); it.hasNext();)
4034 >                h += it.next().hashCode();
4035 >            return h;
4036          }
4037  
4038 <        /**
4039 <         * Returns the result of accumulating the given transformation
4040 <         * of all (key, value) pairs using the given reducer to
4041 <         * combine values, or null if none.
4042 <         *
4043 <         * @param transformer a function returning the transformation
4044 <         * for an element, or null of there is no transformation (in
4045 <         * which case it is not combined).
4046 <         * @param reducer a commutative associative combining function
4047 <         * @return the result of accumulating the given transformation
4048 <         * of all (key, value) pairs
4049 <         */
4050 <        public <U> U reduce(BiFun<? super K, ? super V, ? extends U> transformer,
4051 <                            BiFun<? super U, ? super U, ? extends U> reducer) {
3687 <            return fjp.invoke(ForkJoinTasks.reduce
3688 <                              (ConcurrentHashMapV8.this, transformer, reducer));
4038 >        public final String toString() {
4039 >            StringBuilder sb = new StringBuilder();
4040 >            sb.append('[');
4041 >            Iterator<?> it = iterator();
4042 >            if (it.hasNext()) {
4043 >                for (;;) {
4044 >                    Object e = it.next();
4045 >                    sb.append(e == this ? "(this Collection)" : e);
4046 >                    if (!it.hasNext())
4047 >                        break;
4048 >                    sb.append(',').append(' ');
4049 >                }
4050 >            }
4051 >            return sb.append(']').toString();
4052          }
4053  
4054 <        /**
4055 <         * Returns the result of accumulating the given transformation
4056 <         * of all (key, value) pairs using the given reducer to
4057 <         * combine values, and the given basis as an identity value.
4058 <         *
4059 <         * @param transformer a function returning the transformation
4060 <         * for an element
4061 <         * @param basis the identity (initial default value) for the reduction
4062 <         * @param reducer a commutative associative combining function
4063 <         * @return the result of accumulating the given transformation
4064 <         * of all (key, value) pairs
4065 <         */
4066 <        public double reduceToDouble(ObjectByObjectToDouble<? super K, ? super V> transformer,
4067 <                                     double basis,
4068 <                                     DoubleByDoubleToDouble reducer) {
4069 <            return fjp.invoke(ForkJoinTasks.reduceToDouble
4070 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4054 >        public final boolean containsAll(Collection<?> c) {
4055 >            if (c != this) {
4056 >                for (Iterator<?> it = c.iterator(); it.hasNext();) {
4057 >                    Object e = it.next();
4058 >                    if (e == null || !contains(e))
4059 >                        return false;
4060 >                }
4061 >            }
4062 >            return true;
4063 >        }
4064 >
4065 >        public final boolean removeAll(Collection<?> c) {
4066 >            boolean modified = false;
4067 >            for (Iterator<?> it = iterator(); it.hasNext();) {
4068 >                if (c.contains(it.next())) {
4069 >                    it.remove();
4070 >                    modified = true;
4071 >                }
4072 >            }
4073 >            return modified;
4074 >        }
4075 >
4076 >        public final boolean retainAll(Collection<?> c) {
4077 >            boolean modified = false;
4078 >            for (Iterator<?> it = iterator(); it.hasNext();) {
4079 >                if (!c.contains(it.next())) {
4080 >                    it.remove();
4081 >                    modified = true;
4082 >                }
4083 >            }
4084 >            return modified;
4085 >        }
4086 >
4087 >    }
4088 >
4089 >    /**
4090 >     * A view of a ConcurrentHashMapV8 as a {@link Set} of keys, in
4091 >     * which additions may optionally be enabled by mapping to a
4092 >     * common value.  This class cannot be directly instantiated. See
4093 >     * {@link #keySet}, {@link #keySet(Object)}, {@link #newKeySet()},
4094 >     * {@link #newKeySet(int)}.
4095 >     */
4096 >    public static class KeySetView<K,V> extends CHMView<K,V> implements Set<K>, java.io.Serializable {
4097 >        private static final long serialVersionUID = 7249069246763182397L;
4098 >        private final V value;
4099 >        KeySetView(ConcurrentHashMapV8<K, V> map, V value) {  // non-public
4100 >            super(map);
4101 >            this.value = value;
4102          }
4103  
4104          /**
4105 <         * Returns the result of accumulating the given transformation
4106 <         * of all (key, value) pairs using the given reducer to
3713 <         * combine values, and the given basis as an identity value.
4105 >         * Returns the default mapped value for additions,
4106 >         * or {@code null} if additions are not supported.
4107           *
4108 <         * @param transformer a function returning the transformation
4109 <         * for an element
3717 <         * @param basis the identity (initial default value) for the reduction
3718 <         * @param reducer a commutative associative combining function
3719 <         * @return the result of accumulating the given transformation
3720 <         * of all (key, value) pairs
4108 >         * @return the default mapped value for additions, or {@code null}
4109 >         * if not supported.
4110           */
4111 <        public long reduceToLong(ObjectByObjectToLong<? super K, ? super V> transformer,
4112 <                                 long basis,
4113 <                                 LongByLongToLong reducer) {
4114 <            return fjp.invoke(ForkJoinTasks.reduceToLong
4115 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4116 <        }
4111 >        public V getMappedValue() { return value; }
4112 >
4113 >        // implement Set API
4114 >
4115 >        public boolean contains(Object o) { return map.containsKey(o); }
4116 >        public boolean remove(Object o)   { return map.remove(o) != null; }
4117  
4118          /**
4119 <         * Returns the result of accumulating the given transformation
4120 <         * of all (key, value) pairs using the given reducer to
4121 <         * combine values, and the given basis as an identity value.
4119 >         * Returns a "weakly consistent" iterator that will never
4120 >         * throw {@link ConcurrentModificationException}, and
4121 >         * guarantees to traverse elements as they existed upon
4122 >         * construction of the iterator, and may (but is not
4123 >         * guaranteed to) reflect any modifications subsequent to
4124 >         * construction.
4125           *
4126 <         * @param transformer a function returning the transformation
3735 <         * for an element
3736 <         * @param basis the identity (initial default value) for the reduction
3737 <         * @param reducer a commutative associative combining function
3738 <         * @return the result of accumulating the given transformation
3739 <         * of all (key, value) pairs
4126 >         * @return an iterator over the keys of this map
4127           */
4128 <        public int reduceToInt(ObjectByObjectToInt<? super K, ? super V> transformer,
4129 <                               int basis,
4130 <                               IntByIntToInt reducer) {
4131 <            return fjp.invoke(ForkJoinTasks.reduceToInt
4132 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4128 >        public Iterator<K> iterator()     { return new KeyIterator<K,V>(map); }
4129 >        public boolean add(K e) {
4130 >            V v;
4131 >            if ((v = value) == null)
4132 >                throw new UnsupportedOperationException();
4133 >            if (e == null)
4134 >                throw new NullPointerException();
4135 >            return map.internalPutIfAbsent(e, v) == null;
4136 >        }
4137 >        public boolean addAll(Collection<? extends K> c) {
4138 >            boolean added = false;
4139 >            V v;
4140 >            if ((v = value) == null)
4141 >                throw new UnsupportedOperationException();
4142 >            for (K e : c) {
4143 >                if (e == null)
4144 >                    throw new NullPointerException();
4145 >                if (map.internalPutIfAbsent(e, v) == null)
4146 >                    added = true;
4147 >            }
4148 >            return added;
4149 >        }
4150 >        public boolean equals(Object o) {
4151 >            Set<?> c;
4152 >            return ((o instanceof Set) &&
4153 >                    ((c = (Set<?>)o) == this ||
4154 >                     (containsAll(c) && c.containsAll(this))));
4155          }
4156  
4157          /**
# Line 3750 | Line 4159 | public class ConcurrentHashMapV8<K, V>
4159           *
4160           * @param action the action
4161           */
4162 <        public void forEachKey(Action<K> action) {
4163 <            fjp.invoke(ForkJoinTasks.forEachKey
4164 <                       (ConcurrentHashMapV8.this, action));
4162 >        public void forEach(Action<K> action) {
4163 >            ForkJoinTasks.forEachKey
4164 >                (map, action).invoke();
4165          }
4166  
4167          /**
# Line 3764 | Line 4173 | public class ConcurrentHashMapV8<K, V>
4173           * which case the action is not applied).
4174           * @param action the action
4175           */
4176 <        public <U> void forEachKey(Fun<? super K, ? extends U> transformer,
4177 <                                   Action<U> action) {
4178 <            fjp.invoke(ForkJoinTasks.forEachKey
4179 <                       (ConcurrentHashMapV8.this, transformer, action));
4176 >        public <U> void forEach(Fun<? super K, ? extends U> transformer,
4177 >                                Action<U> action) {
4178 >            ForkJoinTasks.forEachKey
4179 >                (map, transformer, action).invoke();
4180          }
4181  
4182          /**
# Line 3782 | Line 4191 | public class ConcurrentHashMapV8<K, V>
4191           * @return a non-null result from applying the given search
4192           * function on each key, or null if none
4193           */
4194 <        public <U> U searchKeys(Fun<? super K, ? extends U> searchFunction) {
4195 <            return fjp.invoke(ForkJoinTasks.searchKeys
4196 <                              (ConcurrentHashMapV8.this, searchFunction));
4194 >        public <U> U search(Fun<? super K, ? extends U> searchFunction) {
4195 >            return ForkJoinTasks.searchKeys
4196 >                (map, searchFunction).invoke();
4197          }
4198  
4199          /**
# Line 3795 | Line 4204 | public class ConcurrentHashMapV8<K, V>
4204           * @return the result of accumulating all keys using the given
4205           * reducer to combine values, or null if none
4206           */
4207 <        public K reduceKeys(BiFun<? super K, ? super K, ? extends K> reducer) {
4208 <            return fjp.invoke(ForkJoinTasks.reduceKeys
4209 <                              (ConcurrentHashMapV8.this, reducer));
3801 <        }
3802 <
3803 <        /**
3804 <         * Returns the result of accumulating the given transformation
3805 <         * of all keys using the given reducer to combine values, or
3806 <         * null if none.
3807 <         *
3808 <         * @param transformer a function returning the transformation
3809 <         * for an element, or null of there is no transformation (in
3810 <         * which case it is not combined).
3811 <         * @param reducer a commutative associative combining function
3812 <         * @return the result of accumulating the given transformation
3813 <         * of all keys
3814 <         */
3815 <        public <U> U reduceKeys(Fun<? super K, ? extends U> transformer,
3816 <                                BiFun<? super U, ? super U, ? extends U> reducer) {
3817 <            return fjp.invoke(ForkJoinTasks.reduceKeys
3818 <                              (ConcurrentHashMapV8.this, transformer, reducer));
4207 >        public K reduce(BiFun<? super K, ? super K, ? extends K> reducer) {
4208 >            return ForkJoinTasks.reduceKeys
4209 >                (map, reducer).invoke();
4210          }
4211  
4212          /**
# Line 3830 | Line 4221 | public class ConcurrentHashMapV8<K, V>
4221           * @return  the result of accumulating the given transformation
4222           * of all keys
4223           */
4224 <        public double reduceKeysToDouble(ObjectToDouble<? super K> transformer,
4225 <                                         double basis,
4226 <                                         DoubleByDoubleToDouble reducer) {
4227 <            return fjp.invoke(ForkJoinTasks.reduceKeysToDouble
4228 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4224 >        public double reduceToDouble(ObjectToDouble<? super K> transformer,
4225 >                                     double basis,
4226 >                                     DoubleByDoubleToDouble reducer) {
4227 >            return ForkJoinTasks.reduceKeysToDouble
4228 >                (map, transformer, basis, reducer).invoke();
4229          }
4230  
4231 +
4232          /**
4233           * Returns the result of accumulating the given transformation
4234           * of all keys using the given reducer to combine values, and
# Line 3849 | Line 4241 | public class ConcurrentHashMapV8<K, V>
4241           * @return the result of accumulating the given transformation
4242           * of all keys
4243           */
4244 <        public long reduceKeysToLong(ObjectToLong<? super K> transformer,
4245 <                                     long basis,
4246 <                                     LongByLongToLong reducer) {
4247 <            return fjp.invoke(ForkJoinTasks.reduceKeysToLong
4248 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4244 >        public long reduceToLong(ObjectToLong<? super K> transformer,
4245 >                                 long basis,
4246 >                                 LongByLongToLong reducer) {
4247 >            return ForkJoinTasks.reduceKeysToLong
4248 >                (map, transformer, basis, reducer).invoke();
4249          }
4250  
4251          /**
# Line 3868 | Line 4260 | public class ConcurrentHashMapV8<K, V>
4260           * @return the result of accumulating the given transformation
4261           * of all keys
4262           */
4263 <        public int reduceKeysToInt(ObjectToInt<? super K> transformer,
4264 <                                   int basis,
4265 <                                   IntByIntToInt reducer) {
4266 <            return fjp.invoke(ForkJoinTasks.reduceKeysToInt
4267 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4263 >        public int reduceToInt(ObjectToInt<? super K> transformer,
4264 >                               int basis,
4265 >                               IntByIntToInt reducer) {
4266 >            return ForkJoinTasks.reduceKeysToInt
4267 >                (map, transformer, basis, reducer).invoke();
4268 >        }
4269 >
4270 >    }
4271 >
4272 >    /**
4273 >     * A view of a ConcurrentHashMapV8 as a {@link Collection} of
4274 >     * values, in which additions are disabled. This class cannot be
4275 >     * directly instantiated. See {@link #values},
4276 >     *
4277 >     * <p>The view's {@code iterator} is a "weakly consistent" iterator
4278 >     * that will never throw {@link ConcurrentModificationException},
4279 >     * and guarantees to traverse elements as they existed upon
4280 >     * construction of the iterator, and may (but is not guaranteed to)
4281 >     * reflect any modifications subsequent to construction.
4282 >     */
4283 >    public static final class ValuesView<K,V> extends CHMView<K,V>
4284 >        implements Collection<V> {
4285 >        ValuesView(ConcurrentHashMapV8<K, V> map)   { super(map); }
4286 >        public final boolean contains(Object o) { return map.containsValue(o); }
4287 >        public final boolean remove(Object o) {
4288 >            if (o != null) {
4289 >                Iterator<V> it = new ValueIterator<K,V>(map);
4290 >                while (it.hasNext()) {
4291 >                    if (o.equals(it.next())) {
4292 >                        it.remove();
4293 >                        return true;
4294 >                    }
4295 >                }
4296 >            }
4297 >            return false;
4298 >        }
4299 >
4300 >        /**
4301 >         * Returns a "weakly consistent" iterator that will never
4302 >         * throw {@link ConcurrentModificationException}, and
4303 >         * guarantees to traverse elements as they existed upon
4304 >         * construction of the iterator, and may (but is not
4305 >         * guaranteed to) reflect any modifications subsequent to
4306 >         * construction.
4307 >         *
4308 >         * @return an iterator over the values of this map
4309 >         */
4310 >        public final Iterator<V> iterator() {
4311 >            return new ValueIterator<K,V>(map);
4312 >        }
4313 >        public final boolean add(V e) {
4314 >            throw new UnsupportedOperationException();
4315 >        }
4316 >        public final boolean addAll(Collection<? extends V> c) {
4317 >            throw new UnsupportedOperationException();
4318          }
4319  
4320          /**
# Line 3880 | Line 4322 | public class ConcurrentHashMapV8<K, V>
4322           *
4323           * @param action the action
4324           */
4325 <        public void forEachValue(Action<V> action) {
4326 <            fjp.invoke(ForkJoinTasks.forEachValue
4327 <                       (ConcurrentHashMapV8.this, action));
4325 >        public void forEach(Action<V> action) {
4326 >            ForkJoinTasks.forEachValue
4327 >                (map, action).invoke();
4328          }
4329  
4330          /**
# Line 3893 | Line 4335 | public class ConcurrentHashMapV8<K, V>
4335           * for an element, or null of there is no transformation (in
4336           * which case the action is not applied).
4337           */
4338 <        public <U> void forEachValue(Fun<? super V, ? extends U> transformer,
4338 >        public <U> void forEach(Fun<? super V, ? extends U> transformer,
4339                                       Action<U> action) {
4340 <            fjp.invoke(ForkJoinTasks.forEachValue
4341 <                       (ConcurrentHashMapV8.this, transformer, action));
4340 >            ForkJoinTasks.forEachValue
4341 >                (map, transformer, action).invoke();
4342          }
4343  
4344          /**
# Line 3912 | Line 4354 | public class ConcurrentHashMapV8<K, V>
4354           * function on each value, or null if none
4355           *
4356           */
4357 <        public <U> U searchValues(Fun<? super V, ? extends U> searchFunction) {
4358 <            return fjp.invoke(ForkJoinTasks.searchValues
4359 <                              (ConcurrentHashMapV8.this, searchFunction));
4357 >        public <U> U search(Fun<? super V, ? extends U> searchFunction) {
4358 >            return ForkJoinTasks.searchValues
4359 >                (map, searchFunction).invoke();
4360          }
4361  
4362          /**
# Line 3924 | Line 4366 | public class ConcurrentHashMapV8<K, V>
4366           * @param reducer a commutative associative combining function
4367           * @return  the result of accumulating all values
4368           */
4369 <        public V reduceValues(BiFun<? super V, ? super V, ? extends V> reducer) {
4370 <            return fjp.invoke(ForkJoinTasks.reduceValues
4371 <                              (ConcurrentHashMapV8.this, reducer));
4369 >        public V reduce(BiFun<? super V, ? super V, ? extends V> reducer) {
4370 >            return ForkJoinTasks.reduceValues
4371 >                (map, reducer).invoke();
4372          }
4373  
4374          /**
# Line 3941 | Line 4383 | public class ConcurrentHashMapV8<K, V>
4383           * @return the result of accumulating the given transformation
4384           * of all values
4385           */
4386 <        public <U> U reduceValues(Fun<? super V, ? extends U> transformer,
4387 <                                  BiFun<? super U, ? super U, ? extends U> reducer) {
4388 <            return fjp.invoke(ForkJoinTasks.reduceValues
4389 <                              (ConcurrentHashMapV8.this, transformer, reducer));
4386 >        public <U> U reduce(Fun<? super V, ? extends U> transformer,
4387 >                            BiFun<? super U, ? super U, ? extends U> reducer) {
4388 >            return ForkJoinTasks.reduceValues
4389 >                (map, transformer, reducer).invoke();
4390          }
4391  
4392          /**
# Line 3959 | Line 4401 | public class ConcurrentHashMapV8<K, V>
4401           * @return the result of accumulating the given transformation
4402           * of all values
4403           */
4404 <        public double reduceValuesToDouble(ObjectToDouble<? super V> transformer,
4405 <                                           double basis,
4406 <                                           DoubleByDoubleToDouble reducer) {
4407 <            return fjp.invoke(ForkJoinTasks.reduceValuesToDouble
4408 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4404 >        public double reduceToDouble(ObjectToDouble<? super V> transformer,
4405 >                                     double basis,
4406 >                                     DoubleByDoubleToDouble reducer) {
4407 >            return ForkJoinTasks.reduceValuesToDouble
4408 >                (map, transformer, basis, reducer).invoke();
4409          }
4410  
4411          /**
# Line 3978 | Line 4420 | public class ConcurrentHashMapV8<K, V>
4420           * @return the result of accumulating the given transformation
4421           * of all values
4422           */
4423 <        public long reduceValuesToLong(ObjectToLong<? super V> transformer,
4424 <                                       long basis,
4425 <                                       LongByLongToLong reducer) {
4426 <            return fjp.invoke(ForkJoinTasks.reduceValuesToLong
4427 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4423 >        public long reduceToLong(ObjectToLong<? super V> transformer,
4424 >                                 long basis,
4425 >                                 LongByLongToLong reducer) {
4426 >            return ForkJoinTasks.reduceValuesToLong
4427 >                (map, transformer, basis, reducer).invoke();
4428          }
4429  
4430          /**
# Line 3997 | Line 4439 | public class ConcurrentHashMapV8<K, V>
4439           * @return the result of accumulating the given transformation
4440           * of all values
4441           */
4442 <        public int reduceValuesToInt(ObjectToInt<? super V> transformer,
4443 <                                     int basis,
4444 <                                     IntByIntToInt reducer) {
4445 <            return fjp.invoke(ForkJoinTasks.reduceValuesToInt
4446 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4442 >        public int reduceToInt(ObjectToInt<? super V> transformer,
4443 >                               int basis,
4444 >                               IntByIntToInt reducer) {
4445 >            return ForkJoinTasks.reduceValuesToInt
4446 >                (map, transformer, basis, reducer).invoke();
4447 >        }
4448 >
4449 >    }
4450 >
4451 >    /**
4452 >     * A view of a ConcurrentHashMapV8 as a {@link Set} of (key, value)
4453 >     * entries.  This class cannot be directly instantiated. See
4454 >     * {@link #entrySet}.
4455 >     */
4456 >    public static final class EntrySetView<K,V> extends CHMView<K,V>
4457 >        implements Set<Map.Entry<K,V>> {
4458 >        EntrySetView(ConcurrentHashMapV8<K, V> map) { super(map); }
4459 >        public final boolean contains(Object o) {
4460 >            Object k, v, r; Map.Entry<?,?> e;
4461 >            return ((o instanceof Map.Entry) &&
4462 >                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
4463 >                    (r = map.get(k)) != null &&
4464 >                    (v = e.getValue()) != null &&
4465 >                    (v == r || v.equals(r)));
4466 >        }
4467 >        public final boolean remove(Object o) {
4468 >            Object k, v; Map.Entry<?,?> e;
4469 >            return ((o instanceof Map.Entry) &&
4470 >                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
4471 >                    (v = e.getValue()) != null &&
4472 >                    map.remove(k, v));
4473 >        }
4474 >
4475 >        /**
4476 >         * Returns a "weakly consistent" iterator that will never
4477 >         * throw {@link ConcurrentModificationException}, and
4478 >         * guarantees to traverse elements as they existed upon
4479 >         * construction of the iterator, and may (but is not
4480 >         * guaranteed to) reflect any modifications subsequent to
4481 >         * construction.
4482 >         *
4483 >         * @return an iterator over the entries of this map
4484 >         */
4485 >        public final Iterator<Map.Entry<K,V>> iterator() {
4486 >            return new EntryIterator<K,V>(map);
4487 >        }
4488 >
4489 >        public final boolean add(Entry<K,V> e) {
4490 >            K key = e.getKey();
4491 >            V value = e.getValue();
4492 >            if (key == null || value == null)
4493 >                throw new NullPointerException();
4494 >            return map.internalPut(key, value) == null;
4495 >        }
4496 >        public final boolean addAll(Collection<? extends Entry<K,V>> c) {
4497 >            boolean added = false;
4498 >            for (Entry<K,V> e : c) {
4499 >                if (add(e))
4500 >                    added = true;
4501 >            }
4502 >            return added;
4503 >        }
4504 >        public boolean equals(Object o) {
4505 >            Set<?> c;
4506 >            return ((o instanceof Set) &&
4507 >                    ((c = (Set<?>)o) == this ||
4508 >                     (containsAll(c) && c.containsAll(this))));
4509          }
4510  
4511          /**
# Line 4009 | Line 4513 | public class ConcurrentHashMapV8<K, V>
4513           *
4514           * @param action the action
4515           */
4516 <        public void forEachEntry(Action<Map.Entry<K,V>> action) {
4517 <            fjp.invoke(ForkJoinTasks.forEachEntry
4518 <                       (ConcurrentHashMapV8.this, action));
4516 >        public void forEach(Action<Map.Entry<K,V>> action) {
4517 >            ForkJoinTasks.forEachEntry
4518 >                (map, action).invoke();
4519          }
4520  
4521          /**
# Line 4023 | Line 4527 | public class ConcurrentHashMapV8<K, V>
4527           * which case the action is not applied).
4528           * @param action the action
4529           */
4530 <        public <U> void forEachEntry(Fun<Map.Entry<K,V>, ? extends U> transformer,
4531 <                                     Action<U> action) {
4532 <            fjp.invoke(ForkJoinTasks.forEachEntry
4533 <                       (ConcurrentHashMapV8.this, transformer, action));
4530 >        public <U> void forEach(Fun<Map.Entry<K,V>, ? extends U> transformer,
4531 >                                Action<U> action) {
4532 >            ForkJoinTasks.forEachEntry
4533 >                (map, transformer, action).invoke();
4534          }
4535  
4536          /**
# Line 4041 | Line 4545 | public class ConcurrentHashMapV8<K, V>
4545           * @return a non-null result from applying the given search
4546           * function on each entry, or null if none
4547           */
4548 <        public <U> U searchEntries(Fun<Map.Entry<K,V>, ? extends U> searchFunction) {
4549 <            return fjp.invoke(ForkJoinTasks.searchEntries
4550 <                              (ConcurrentHashMapV8.this, searchFunction));
4548 >        public <U> U search(Fun<Map.Entry<K,V>, ? extends U> searchFunction) {
4549 >            return ForkJoinTasks.searchEntries
4550 >                (map, searchFunction).invoke();
4551          }
4552  
4553          /**
# Line 4053 | Line 4557 | public class ConcurrentHashMapV8<K, V>
4557           * @param reducer a commutative associative combining function
4558           * @return the result of accumulating all entries
4559           */
4560 <        public Map.Entry<K,V> reduceEntries(BiFun<Map.Entry<K,V>, Map.Entry<K,V>, ? extends Map.Entry<K,V>> reducer) {
4561 <            return fjp.invoke(ForkJoinTasks.reduceEntries
4562 <                              (ConcurrentHashMapV8.this, reducer));
4560 >        public Map.Entry<K,V> reduce(BiFun<Map.Entry<K,V>, Map.Entry<K,V>, ? extends Map.Entry<K,V>> reducer) {
4561 >            return ForkJoinTasks.reduceEntries
4562 >                (map, reducer).invoke();
4563          }
4564  
4565          /**
# Line 4070 | Line 4574 | public class ConcurrentHashMapV8<K, V>
4574           * @return the result of accumulating the given transformation
4575           * of all entries
4576           */
4577 <        public <U> U reduceEntries(Fun<Map.Entry<K,V>, ? extends U> transformer,
4578 <                                   BiFun<? super U, ? super U, ? extends U> reducer) {
4579 <            return fjp.invoke(ForkJoinTasks.reduceEntries
4580 <                              (ConcurrentHashMapV8.this, transformer, reducer));
4577 >        public <U> U reduce(Fun<Map.Entry<K,V>, ? extends U> transformer,
4578 >                            BiFun<? super U, ? super U, ? extends U> reducer) {
4579 >            return ForkJoinTasks.reduceEntries
4580 >                (map, transformer, reducer).invoke();
4581          }
4582  
4583          /**
# Line 4088 | Line 4592 | public class ConcurrentHashMapV8<K, V>
4592           * @return the result of accumulating the given transformation
4593           * of all entries
4594           */
4595 <        public double reduceEntriesToDouble(ObjectToDouble<Map.Entry<K,V>> transformer,
4596 <                                            double basis,
4597 <                                            DoubleByDoubleToDouble reducer) {
4598 <            return fjp.invoke(ForkJoinTasks.reduceEntriesToDouble
4599 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4595 >        public double reduceToDouble(ObjectToDouble<Map.Entry<K,V>> transformer,
4596 >                                     double basis,
4597 >                                     DoubleByDoubleToDouble reducer) {
4598 >            return ForkJoinTasks.reduceEntriesToDouble
4599 >                (map, transformer, basis, reducer).invoke();
4600          }
4601  
4602          /**
# Line 4107 | Line 4611 | public class ConcurrentHashMapV8<K, V>
4611           * @return  the result of accumulating the given transformation
4612           * of all entries
4613           */
4614 <        public long reduceEntriesToLong(ObjectToLong<Map.Entry<K,V>> transformer,
4615 <                                        long basis,
4616 <                                        LongByLongToLong reducer) {
4617 <            return fjp.invoke(ForkJoinTasks.reduceEntriesToLong
4618 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4614 >        public long reduceToLong(ObjectToLong<Map.Entry<K,V>> transformer,
4615 >                                 long basis,
4616 >                                 LongByLongToLong reducer) {
4617 >            return ForkJoinTasks.reduceEntriesToLong
4618 >                (map, transformer, basis, reducer).invoke();
4619          }
4620  
4621          /**
# Line 4126 | Line 4630 | public class ConcurrentHashMapV8<K, V>
4630           * @return the result of accumulating the given transformation
4631           * of all entries
4632           */
4633 <        public int reduceEntriesToInt(ObjectToInt<Map.Entry<K,V>> transformer,
4634 <                                      int basis,
4635 <                                      IntByIntToInt reducer) {
4636 <            return fjp.invoke(ForkJoinTasks.reduceEntriesToInt
4637 <                              (ConcurrentHashMapV8.this, transformer, basis, reducer));
4633 >        public int reduceToInt(ObjectToInt<Map.Entry<K,V>> transformer,
4634 >                               int basis,
4635 >                               IntByIntToInt reducer) {
4636 >            return ForkJoinTasks.reduceEntriesToInt
4637 >                (map, transformer, basis, reducer).invoke();
4638          }
4639 +
4640      }
4641  
4642      // ---------------------------------------------------------------------
4643  
4644      /**
4645       * Predefined tasks for performing bulk parallel operations on
4646 <     * ConcurrentHashMaps. These tasks follow the forms and rules used
4647 <     * in class {@link Parallel}. Each method has the same name, but
4648 <     * returns a task rather than invoking it. These methods may be
4649 <     * useful in custom applications such as submitting a task without
4650 <     * waiting for completion, or combining with other tasks.
4646 >     * ConcurrentHashMapV8s. These tasks follow the forms and rules used
4647 >     * for bulk operations. Each method has the same name, but returns
4648 >     * a task rather than invoking it. These methods may be useful in
4649 >     * custom applications such as submitting a task without waiting
4650 >     * for completion, using a custom pool, or combining with other
4651 >     * tasks.
4652       */
4653      public static class ForkJoinTasks {
4654          private ForkJoinTasks() {}
# Line 4159 | Line 4665 | public class ConcurrentHashMapV8<K, V>
4665              (ConcurrentHashMapV8<K,V> map,
4666               BiAction<K,V> action) {
4667              if (action == null) throw new NullPointerException();
4668 <            return new ForEachMappingTask<K,V>(map, action);
4668 >            return new ForEachMappingTask<K,V>(map, null, -1, null, action);
4669          }
4670  
4671          /**
# Line 4168 | Line 4674 | public class ConcurrentHashMapV8<K, V>
4674           *
4675           * @param map the map
4676           * @param transformer a function returning the transformation
4677 <         * for an element, or null of there is no transformation (in
4678 <         * which case the action is not applied).
4677 >         * for an element, or null if there is no transformation (in
4678 >         * which case the action is not applied)
4679           * @param action the action
4680           * @return the task
4681           */
# Line 4180 | Line 4686 | public class ConcurrentHashMapV8<K, V>
4686              if (transformer == null || action == null)
4687                  throw new NullPointerException();
4688              return new ForEachTransformedMappingTask<K,V,U>
4689 <                (map, transformer, action);
4689 >                (map, null, -1, null, transformer, action);
4690          }
4691  
4692          /**
# Line 4200 | Line 4706 | public class ConcurrentHashMapV8<K, V>
4706               BiFun<? super K, ? super V, ? extends U> searchFunction) {
4707              if (searchFunction == null) throw new NullPointerException();
4708              return new SearchMappingsTask<K,V,U>
4709 <                (map, searchFunction,
4709 >                (map, null, -1, null, searchFunction,
4710                   new AtomicReference<U>());
4711          }
4712  
# Line 4211 | Line 4717 | public class ConcurrentHashMapV8<K, V>
4717           *
4718           * @param map the map
4719           * @param transformer a function returning the transformation
4720 <         * for an element, or null of there is no transformation (in
4720 >         * for an element, or null if there is no transformation (in
4721           * which case it is not combined).
4722           * @param reducer a commutative associative combining function
4723           * @return the task
# Line 4223 | Line 4729 | public class ConcurrentHashMapV8<K, V>
4729              if (transformer == null || reducer == null)
4730                  throw new NullPointerException();
4731              return new MapReduceMappingsTask<K,V,U>
4732 <                (map, transformer, reducer);
4732 >                (map, null, -1, null, transformer, reducer);
4733          }
4734  
4735          /**
# Line 4247 | Line 4753 | public class ConcurrentHashMapV8<K, V>
4753              if (transformer == null || reducer == null)
4754                  throw new NullPointerException();
4755              return new MapReduceMappingsToDoubleTask<K,V>
4756 <                (map, transformer, basis, reducer);
4756 >                (map, null, -1, null, transformer, basis, reducer);
4757          }
4758  
4759          /**
# Line 4271 | Line 4777 | public class ConcurrentHashMapV8<K, V>
4777              if (transformer == null || reducer == null)
4778                  throw new NullPointerException();
4779              return new MapReduceMappingsToLongTask<K,V>
4780 <                (map, transformer, basis, reducer);
4780 >                (map, null, -1, null, transformer, basis, reducer);
4781          }
4782  
4783          /**
# Line 4294 | Line 4800 | public class ConcurrentHashMapV8<K, V>
4800              if (transformer == null || reducer == null)
4801                  throw new NullPointerException();
4802              return new MapReduceMappingsToIntTask<K,V>
4803 <                (map, transformer, basis, reducer);
4803 >                (map, null, -1, null, transformer, basis, reducer);
4804          }
4805  
4806          /**
# Line 4309 | Line 4815 | public class ConcurrentHashMapV8<K, V>
4815              (ConcurrentHashMapV8<K,V> map,
4816               Action<K> action) {
4817              if (action == null) throw new NullPointerException();
4818 <            return new ForEachKeyTask<K,V>(map, action);
4818 >            return new ForEachKeyTask<K,V>(map, null, -1, null, action);
4819          }
4820  
4821          /**
# Line 4318 | Line 4824 | public class ConcurrentHashMapV8<K, V>
4824           *
4825           * @param map the map
4826           * @param transformer a function returning the transformation
4827 <         * for an element, or null of there is no transformation (in
4828 <         * which case the action is not applied).
4827 >         * for an element, or null if there is no transformation (in
4828 >         * which case the action is not applied)
4829           * @param action the action
4830           * @return the task
4831           */
# Line 4330 | Line 4836 | public class ConcurrentHashMapV8<K, V>
4836              if (transformer == null || action == null)
4837                  throw new NullPointerException();
4838              return new ForEachTransformedKeyTask<K,V,U>
4839 <                (map, transformer, action);
4839 >                (map, null, -1, null, transformer, action);
4840          }
4841  
4842          /**
# Line 4350 | Line 4856 | public class ConcurrentHashMapV8<K, V>
4856               Fun<? super K, ? extends U> searchFunction) {
4857              if (searchFunction == null) throw new NullPointerException();
4858              return new SearchKeysTask<K,V,U>
4859 <                (map, searchFunction,
4859 >                (map, null, -1, null, searchFunction,
4860                   new AtomicReference<U>());
4861          }
4862  
# Line 4368 | Line 4874 | public class ConcurrentHashMapV8<K, V>
4874               BiFun<? super K, ? super K, ? extends K> reducer) {
4875              if (reducer == null) throw new NullPointerException();
4876              return new ReduceKeysTask<K,V>
4877 <                (map, reducer);
4877 >                (map, null, -1, null, reducer);
4878          }
4879  
4880          /**
# Line 4378 | Line 4884 | public class ConcurrentHashMapV8<K, V>
4884           *
4885           * @param map the map
4886           * @param transformer a function returning the transformation
4887 <         * for an element, or null of there is no transformation (in
4887 >         * for an element, or null if there is no transformation (in
4888           * which case it is not combined).
4889           * @param reducer a commutative associative combining function
4890           * @return the task
# Line 4390 | Line 4896 | public class ConcurrentHashMapV8<K, V>
4896              if (transformer == null || reducer == null)
4897                  throw new NullPointerException();
4898              return new MapReduceKeysTask<K,V,U>
4899 <                (map, transformer, reducer);
4899 >                (map, null, -1, null, transformer, reducer);
4900          }
4901  
4902          /**
# Line 4414 | Line 4920 | public class ConcurrentHashMapV8<K, V>
4920              if (transformer == null || reducer == null)
4921                  throw new NullPointerException();
4922              return new MapReduceKeysToDoubleTask<K,V>
4923 <                (map, transformer, basis, reducer);
4923 >                (map, null, -1, null, transformer, basis, reducer);
4924          }
4925  
4926          /**
# Line 4438 | Line 4944 | public class ConcurrentHashMapV8<K, V>
4944              if (transformer == null || reducer == null)
4945                  throw new NullPointerException();
4946              return new MapReduceKeysToLongTask<K,V>
4947 <                (map, transformer, basis, reducer);
4947 >                (map, null, -1, null, transformer, basis, reducer);
4948          }
4949  
4950          /**
# Line 4462 | Line 4968 | public class ConcurrentHashMapV8<K, V>
4968              if (transformer == null || reducer == null)
4969                  throw new NullPointerException();
4970              return new MapReduceKeysToIntTask<K,V>
4971 <                (map, transformer, basis, reducer);
4971 >                (map, null, -1, null, transformer, basis, reducer);
4972          }
4973  
4974          /**
# Line 4476 | Line 4982 | public class ConcurrentHashMapV8<K, V>
4982              (ConcurrentHashMapV8<K,V> map,
4983               Action<V> action) {
4984              if (action == null) throw new NullPointerException();
4985 <            return new ForEachValueTask<K,V>(map, action);
4985 >            return new ForEachValueTask<K,V>(map, null, -1, null, action);
4986          }
4987  
4988          /**
# Line 4485 | Line 4991 | public class ConcurrentHashMapV8<K, V>
4991           *
4992           * @param map the map
4993           * @param transformer a function returning the transformation
4994 <         * for an element, or null of there is no transformation (in
4995 <         * which case the action is not applied).
4994 >         * for an element, or null if there is no transformation (in
4995 >         * which case the action is not applied)
4996           * @param action the action
4997           */
4998          public static <K,V,U> ForkJoinTask<Void> forEachValue
# Line 4496 | Line 5002 | public class ConcurrentHashMapV8<K, V>
5002              if (transformer == null || action == null)
5003                  throw new NullPointerException();
5004              return new ForEachTransformedValueTask<K,V,U>
5005 <                (map, transformer, action);
5005 >                (map, null, -1, null, transformer, action);
5006          }
5007  
5008          /**
# Line 4510 | Line 5016 | public class ConcurrentHashMapV8<K, V>
5016           * @param searchFunction a function returning a non-null
5017           * result on success, else null
5018           * @return the task
4513 –         *
5019           */
5020          public static <K,V,U> ForkJoinTask<U> searchValues
5021              (ConcurrentHashMapV8<K,V> map,
5022               Fun<? super V, ? extends U> searchFunction) {
5023              if (searchFunction == null) throw new NullPointerException();
5024              return new SearchValuesTask<K,V,U>
5025 <                (map, searchFunction,
5025 >                (map, null, -1, null, searchFunction,
5026                   new AtomicReference<U>());
5027          }
5028  
# Line 4535 | Line 5040 | public class ConcurrentHashMapV8<K, V>
5040               BiFun<? super V, ? super V, ? extends V> reducer) {
5041              if (reducer == null) throw new NullPointerException();
5042              return new ReduceValuesTask<K,V>
5043 <                (map, reducer);
5043 >                (map, null, -1, null, reducer);
5044          }
5045  
5046          /**
# Line 4545 | Line 5050 | public class ConcurrentHashMapV8<K, V>
5050           *
5051           * @param map the map
5052           * @param transformer a function returning the transformation
5053 <         * for an element, or null of there is no transformation (in
5053 >         * for an element, or null if there is no transformation (in
5054           * which case it is not combined).
5055           * @param reducer a commutative associative combining function
5056           * @return the task
# Line 4557 | Line 5062 | public class ConcurrentHashMapV8<K, V>
5062              if (transformer == null || reducer == null)
5063                  throw new NullPointerException();
5064              return new MapReduceValuesTask<K,V,U>
5065 <                (map, transformer, reducer);
5065 >                (map, null, -1, null, transformer, reducer);
5066          }
5067  
5068          /**
# Line 4581 | Line 5086 | public class ConcurrentHashMapV8<K, V>
5086              if (transformer == null || reducer == null)
5087                  throw new NullPointerException();
5088              return new MapReduceValuesToDoubleTask<K,V>
5089 <                (map, transformer, basis, reducer);
5089 >                (map, null, -1, null, transformer, basis, reducer);
5090          }
5091  
5092          /**
# Line 4605 | Line 5110 | public class ConcurrentHashMapV8<K, V>
5110              if (transformer == null || reducer == null)
5111                  throw new NullPointerException();
5112              return new MapReduceValuesToLongTask<K,V>
5113 <                (map, transformer, basis, reducer);
5113 >                (map, null, -1, null, transformer, basis, reducer);
5114          }
5115  
5116          /**
# Line 4629 | Line 5134 | public class ConcurrentHashMapV8<K, V>
5134              if (transformer == null || reducer == null)
5135                  throw new NullPointerException();
5136              return new MapReduceValuesToIntTask<K,V>
5137 <                (map, transformer, basis, reducer);
5137 >                (map, null, -1, null, transformer, basis, reducer);
5138          }
5139  
5140          /**
# Line 4643 | Line 5148 | public class ConcurrentHashMapV8<K, V>
5148              (ConcurrentHashMapV8<K,V> map,
5149               Action<Map.Entry<K,V>> action) {
5150              if (action == null) throw new NullPointerException();
5151 <            return new ForEachEntryTask<K,V>(map, action);
5151 >            return new ForEachEntryTask<K,V>(map, null, -1, null, action);
5152          }
5153  
5154          /**
# Line 4652 | Line 5157 | public class ConcurrentHashMapV8<K, V>
5157           *
5158           * @param map the map
5159           * @param transformer a function returning the transformation
5160 <         * for an element, or null of there is no transformation (in
5161 <         * which case the action is not applied).
5160 >         * for an element, or null if there is no transformation (in
5161 >         * which case the action is not applied)
5162           * @param action the action
5163           */
5164          public static <K,V,U> ForkJoinTask<Void> forEachEntry
# Line 4663 | Line 5168 | public class ConcurrentHashMapV8<K, V>
5168              if (transformer == null || action == null)
5169                  throw new NullPointerException();
5170              return new ForEachTransformedEntryTask<K,V,U>
5171 <                (map, transformer, action);
5171 >                (map, null, -1, null, transformer, action);
5172          }
5173  
5174          /**
# Line 4677 | Line 5182 | public class ConcurrentHashMapV8<K, V>
5182           * @param searchFunction a function returning a non-null
5183           * result on success, else null
5184           * @return the task
4680 –         *
5185           */
5186          public static <K,V,U> ForkJoinTask<U> searchEntries
5187              (ConcurrentHashMapV8<K,V> map,
5188               Fun<Map.Entry<K,V>, ? extends U> searchFunction) {
5189              if (searchFunction == null) throw new NullPointerException();
5190              return new SearchEntriesTask<K,V,U>
5191 <                (map, searchFunction,
5191 >                (map, null, -1, null, searchFunction,
5192                   new AtomicReference<U>());
5193          }
5194  
# Line 4702 | Line 5206 | public class ConcurrentHashMapV8<K, V>
5206               BiFun<Map.Entry<K,V>, Map.Entry<K,V>, ? extends Map.Entry<K,V>> reducer) {
5207              if (reducer == null) throw new NullPointerException();
5208              return new ReduceEntriesTask<K,V>
5209 <                (map, reducer);
5209 >                (map, null, -1, null, reducer);
5210          }
5211  
5212          /**
# Line 4712 | Line 5216 | public class ConcurrentHashMapV8<K, V>
5216           *
5217           * @param map the map
5218           * @param transformer a function returning the transformation
5219 <         * for an element, or null of there is no transformation (in
5219 >         * for an element, or null if there is no transformation (in
5220           * which case it is not combined).
5221           * @param reducer a commutative associative combining function
5222           * @return the task
# Line 4724 | Line 5228 | public class ConcurrentHashMapV8<K, V>
5228              if (transformer == null || reducer == null)
5229                  throw new NullPointerException();
5230              return new MapReduceEntriesTask<K,V,U>
5231 <                (map, transformer, reducer);
5231 >                (map, null, -1, null, transformer, reducer);
5232          }
5233  
5234          /**
# Line 4748 | Line 5252 | public class ConcurrentHashMapV8<K, V>
5252              if (transformer == null || reducer == null)
5253                  throw new NullPointerException();
5254              return new MapReduceEntriesToDoubleTask<K,V>
5255 <                (map, transformer, basis, reducer);
5255 >                (map, null, -1, null, transformer, basis, reducer);
5256          }
5257  
5258          /**
# Line 4772 | Line 5276 | public class ConcurrentHashMapV8<K, V>
5276              if (transformer == null || reducer == null)
5277                  throw new NullPointerException();
5278              return new MapReduceEntriesToLongTask<K,V>
5279 <                (map, transformer, basis, reducer);
5279 >                (map, null, -1, null, transformer, basis, reducer);
5280          }
5281  
5282          /**
# Line 4796 | Line 5300 | public class ConcurrentHashMapV8<K, V>
5300              if (transformer == null || reducer == null)
5301                  throw new NullPointerException();
5302              return new MapReduceEntriesToIntTask<K,V>
5303 <                (map, transformer, basis, reducer);
5303 >                (map, null, -1, null, transformer, basis, reducer);
5304          }
5305      }
5306  
# Line 4815 | Line 5319 | public class ConcurrentHashMapV8<K, V>
5319       */
5320      @SuppressWarnings("serial") static abstract class BulkTask<K,V,R> extends Traverser<K,V,R> {
5321          final BulkTask<K,V,?> parent;  // completion target
5322 <        int batch;                     // split control
5322 >        int batch;                     // split control; -1 for unknown
5323          int pending;                   // completion control
5324  
5325 <        /** Constructor for root tasks */
5326 <        BulkTask(ConcurrentHashMapV8<K,V> map) {
5325 >        BulkTask(ConcurrentHashMapV8<K,V> map, BulkTask<K,V,?> parent,
5326 >                 int batch) {
5327              super(map);
4824 –            this.parent = null;
4825 –            this.batch = -1; // force call to batch() on execution
4826 –        }
4827 –
4828 –        /** Constructor for subtasks */
4829 –        BulkTask(BulkTask<K,V,?> parent, int batch) {
4830 –            super(parent);
5328              this.parent = parent;
5329              this.batch = batch;
5330 <        }
5331 <
5332 <        // FJ methods
5333 <
5334 <        /**
5335 <         * Propagates completion. Note that all reduce actions
5336 <         * bypass this method to combine while completing.
5337 <         */
5338 <        final void tryComplete() {
5339 <            BulkTask<K,V,?> a = this, s = a;
4843 <            for (int c;;) {
4844 <                if ((c = a.pending) == 0) {
4845 <                    if ((a = (s = a).parent) == null) {
4846 <                        s.quietlyComplete();
4847 <                        break;
4848 <                    }
4849 <                }
4850 <                else if (U.compareAndSwapInt(a, PENDING, c, c - 1))
4851 <                    break;
5330 >            if (parent != null && map != null) { // split parent
5331 >                Node[] t;
5332 >                if ((t = parent.tab) == null &&
5333 >                    (t = parent.tab = map.table) != null)
5334 >                    parent.baseLimit = parent.baseSize = t.length;
5335 >                this.tab = t;
5336 >                this.baseSize = parent.baseSize;
5337 >                int hi = this.baseLimit = parent.baseLimit;
5338 >                parent.baseLimit = this.index = this.baseIndex =
5339 >                    (hi + parent.baseIndex + 1) >>> 1;
5340              }
5341          }
5342  
# Line 4893 | Line 5381 | public class ConcurrentHashMapV8<K, V>
5381           * dividing by two anyway.
5382           */
5383          final int batch() {
5384 <            int b = batch;
5385 <            if (b < 0) {
5386 <                long n = map.counter.sum();
5387 <                int sp = getPool().getParallelism() << 3; // slack of 8
5388 <                b = batch = (n <= 0L) ? 0 : (n < (long)sp) ? (int)n : sp;
5384 >            ConcurrentHashMapV8<K, V> m; int b; Node[] t;  ForkJoinPool pool;
5385 >            if ((b = batch) < 0 && (m = map) != null) { // force initialization
5386 >                if ((t = tab) == null && (t = tab = m.table) != null)
5387 >                    baseLimit = baseSize = t.length;
5388 >                if (t != null) {
5389 >                    long n = m.counter.sum();
5390 >                    int par = ((pool = getPool()) == null) ?
5391 >                        ForkJoinPool.getCommonPoolParallelism() :
5392 >                        pool.getParallelism();
5393 >                    int sp = par << 3; // slack of 8
5394 >                    b = batch = (n <= 0L) ? 0 : (n < (long)sp) ? (int)n : sp;
5395 >                }
5396              }
5397              return b;
5398          }
# Line 4923 | Line 5418 | public class ConcurrentHashMapV8<K, V>
5418          }
5419      }
5420  
5421 +    /**
5422 +     * Base class for non-reductive actions
5423 +     */
5424 +    @SuppressWarnings("serial") static abstract class BulkAction<K,V,R> extends BulkTask<K,V,R> {
5425 +        BulkAction<K,V,?> nextTask;
5426 +        BulkAction(ConcurrentHashMapV8<K,V> map, BulkTask<K,V,?> parent,
5427 +                   int batch, BulkAction<K,V,?> nextTask) {
5428 +            super(map, parent, batch);
5429 +            this.nextTask = nextTask;
5430 +        }
5431 +
5432 +        /**
5433 +         * Try to complete task and upward parents. Upon hitting
5434 +         * non-completed parent, if a non-FJ task, try to help out the
5435 +         * computation.
5436 +         */
5437 +        final void tryComplete(BulkAction<K,V,?> subtasks) {
5438 +            BulkTask<K,V,?> a = this, s = a;
5439 +            for (int c;;) {
5440 +                if ((c = a.pending) == 0) {
5441 +                    if ((a = (s = a).parent) == null) {
5442 +                        s.quietlyComplete();
5443 +                        break;
5444 +                    }
5445 +                }
5446 +                else if (a.casPending(c, c - 1)) {
5447 +                    if (subtasks != null && !inForkJoinPool()) {
5448 +                        while ((s = a.parent) != null)
5449 +                            a = s;
5450 +                        while (!a.isDone()) {
5451 +                            BulkAction<K,V,?> next = subtasks.nextTask;
5452 +                            if (subtasks.tryUnfork())
5453 +                                subtasks.exec();
5454 +                            if ((subtasks = next) == null)
5455 +                                break;
5456 +                        }
5457 +                    }
5458 +                    break;
5459 +                }
5460 +            }
5461 +        }
5462 +
5463 +    }
5464 +
5465      /*
5466       * Task classes. Coded in a regular but ugly format/style to
5467       * simplify checks that each variant differs in the right way from
# Line 4930 | Line 5469 | public class ConcurrentHashMapV8<K, V>
5469       */
5470  
5471      @SuppressWarnings("serial") static final class ForEachKeyTask<K,V>
5472 <        extends BulkTask<K,V,Void> {
5472 >        extends BulkAction<K,V,Void> {
5473          final Action<K> action;
5474          ForEachKeyTask
5475 <            (ConcurrentHashMapV8<K,V> m,
5476 <             Action<K> action) {
4938 <            super(m);
4939 <            this.action = action;
4940 <        }
4941 <        ForEachKeyTask
4942 <            (BulkTask<K,V,?> p, int b,
5475 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5476 >             ForEachKeyTask<K,V> nextTask,
5477               Action<K> action) {
5478 <            super(p, b);
5478 >            super(m, p, b, nextTask);
5479              this.action = action;
5480          }
5481          @SuppressWarnings("unchecked") public final boolean exec() {
5482              final Action<K> action = this.action;
5483              if (action == null)
5484                  return abortOnNullFunction();
5485 +            ForEachKeyTask<K,V> subtasks = null;
5486              try {
5487                  int b = batch(), c;
5488                  while (b > 1 && baseIndex != baseLimit) {
5489                      do {} while (!casPending(c = pending, c+1));
5490 <                    new ForEachKeyTask<K,V>(this, b >>>= 1, action).fork();
5490 >                    (subtasks = new ForEachKeyTask<K,V>
5491 >                     (map, this, b >>>= 1, subtasks, action)).fork();
5492                  }
5493                  while (advance() != null)
5494                      action.apply((K)nextKey);
4959 –                tryComplete();
5495              } catch (Throwable ex) {
5496                  return tryCompleteComputation(ex);
5497              }
5498 +            tryComplete(subtasks);
5499              return false;
5500          }
5501      }
5502  
5503      @SuppressWarnings("serial") static final class ForEachValueTask<K,V>
5504 <        extends BulkTask<K,V,Void> {
5504 >        extends BulkAction<K,V,Void> {
5505          final Action<V> action;
5506          ForEachValueTask
5507 <            (ConcurrentHashMapV8<K,V> m,
5507 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5508 >             ForEachValueTask<K,V> nextTask,
5509               Action<V> action) {
5510 <            super(m);
4974 <            this.action = action;
4975 <        }
4976 <        ForEachValueTask
4977 <            (BulkTask<K,V,?> p, int b,
4978 <             Action<V> action) {
4979 <            super(p, b);
5510 >            super(m, p, b, nextTask);
5511              this.action = action;
5512          }
5513          @SuppressWarnings("unchecked") public final boolean exec() {
5514              final Action<V> action = this.action;
5515              if (action == null)
5516                  return abortOnNullFunction();
5517 +            ForEachValueTask<K,V> subtasks = null;
5518              try {
5519                  int b = batch(), c;
5520                  while (b > 1 && baseIndex != baseLimit) {
5521                      do {} while (!casPending(c = pending, c+1));
5522 <                    new ForEachValueTask<K,V>(this, b >>>= 1, action).fork();
5522 >                    (subtasks = new ForEachValueTask<K,V>
5523 >                     (map, this, b >>>= 1, subtasks, action)).fork();
5524                  }
5525                  Object v;
5526                  while ((v = advance()) != null)
5527                      action.apply((V)v);
4995 –                tryComplete();
5528              } catch (Throwable ex) {
5529                  return tryCompleteComputation(ex);
5530              }
5531 +            tryComplete(subtasks);
5532              return false;
5533          }
5534      }
5535  
5536      @SuppressWarnings("serial") static final class ForEachEntryTask<K,V>
5537 <        extends BulkTask<K,V,Void> {
5537 >        extends BulkAction<K,V,Void> {
5538          final Action<Entry<K,V>> action;
5539          ForEachEntryTask
5540 <            (ConcurrentHashMapV8<K,V> m,
5541 <             Action<Entry<K,V>> action) {
5009 <            super(m);
5010 <            this.action = action;
5011 <        }
5012 <        ForEachEntryTask
5013 <            (BulkTask<K,V,?> p, int b,
5540 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5541 >             ForEachEntryTask<K,V> nextTask,
5542               Action<Entry<K,V>> action) {
5543 <            super(p, b);
5543 >            super(m, p, b, nextTask);
5544              this.action = action;
5545          }
5546          @SuppressWarnings("unchecked") public final boolean exec() {
5547              final Action<Entry<K,V>> action = this.action;
5548              if (action == null)
5549                  return abortOnNullFunction();
5550 +            ForEachEntryTask<K,V> subtasks = null;
5551              try {
5552                  int b = batch(), c;
5553                  while (b > 1 && baseIndex != baseLimit) {
5554                      do {} while (!casPending(c = pending, c+1));
5555 <                    new ForEachEntryTask<K,V>(this, b >>>= 1, action).fork();
5555 >                    (subtasks = new ForEachEntryTask<K,V>
5556 >                     (map, this, b >>>= 1, subtasks, action)).fork();
5557                  }
5558                  Object v;
5559                  while ((v = advance()) != null)
5560                      action.apply(entryFor((K)nextKey, (V)v));
5031 –                tryComplete();
5561              } catch (Throwable ex) {
5562                  return tryCompleteComputation(ex);
5563              }
5564 +            tryComplete(subtasks);
5565              return false;
5566          }
5567      }
5568  
5569      @SuppressWarnings("serial") static final class ForEachMappingTask<K,V>
5570 <        extends BulkTask<K,V,Void> {
5570 >        extends BulkAction<K,V,Void> {
5571          final BiAction<K,V> action;
5572          ForEachMappingTask
5573 <            (ConcurrentHashMapV8<K,V> m,
5573 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5574 >             ForEachMappingTask<K,V> nextTask,
5575               BiAction<K,V> action) {
5576 <            super(m);
5576 >            super(m, p, b, nextTask);
5577              this.action = action;
5578          }
5048 –        ForEachMappingTask
5049 –            (BulkTask<K,V,?> p, int b,
5050 –             BiAction<K,V> action) {
5051 –            super(p, b);
5052 –            this.action = action;
5053 –        }
5054 –
5579          @SuppressWarnings("unchecked") public final boolean exec() {
5580              final BiAction<K,V> action = this.action;
5581              if (action == null)
5582                  return abortOnNullFunction();
5583 +            ForEachMappingTask<K,V> subtasks = null;
5584              try {
5585                  int b = batch(), c;
5586                  while (b > 1 && baseIndex != baseLimit) {
5587                      do {} while (!casPending(c = pending, c+1));
5588 <                    new ForEachMappingTask<K,V>(this, b >>>= 1,
5589 <                                                action).fork();
5588 >                    (subtasks = new ForEachMappingTask<K,V>
5589 >                     (map, this, b >>>= 1, subtasks, action)).fork();
5590                  }
5591                  Object v;
5592                  while ((v = advance()) != null)
5593                      action.apply((K)nextKey, (V)v);
5069 –                tryComplete();
5594              } catch (Throwable ex) {
5595                  return tryCompleteComputation(ex);
5596              }
5597 +            tryComplete(subtasks);
5598              return false;
5599          }
5600      }
5601  
5602      @SuppressWarnings("serial") static final class ForEachTransformedKeyTask<K,V,U>
5603 <        extends BulkTask<K,V,Void> {
5603 >        extends BulkAction<K,V,Void> {
5604          final Fun<? super K, ? extends U> transformer;
5605          final Action<U> action;
5606          ForEachTransformedKeyTask
5607 <            (ConcurrentHashMapV8<K,V> m,
5607 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5608 >             ForEachTransformedKeyTask<K,V,U> nextTask,
5609               Fun<? super K, ? extends U> transformer,
5610               Action<U> action) {
5611 <            super(m);
5611 >            super(m, p, b, nextTask);
5612              this.transformer = transformer;
5613              this.action = action;
5614  
5615          }
5090 –        ForEachTransformedKeyTask
5091 –            (BulkTask<K,V,?> p, int b,
5092 –             Fun<? super K, ? extends U> transformer,
5093 –             Action<U> action) {
5094 –            super(p, b);
5095 –            this.transformer = transformer;
5096 –            this.action = action;
5097 –        }
5616          @SuppressWarnings("unchecked") public final boolean exec() {
5617              final Fun<? super K, ? extends U> transformer =
5618                  this.transformer;
5619              final Action<U> action = this.action;
5620              if (transformer == null || action == null)
5621                  return abortOnNullFunction();
5622 +            ForEachTransformedKeyTask<K,V,U> subtasks = null;
5623              try {
5624                  int b = batch(), c;
5625                  while (b > 1 && baseIndex != baseLimit) {
5626                      do {} while (!casPending(c = pending, c+1));
5627 <                    new ForEachTransformedKeyTask<K,V,U>
5628 <                        (this, b >>>= 1, transformer, action).fork();
5627 >                    (subtasks = new ForEachTransformedKeyTask<K,V,U>
5628 >                     (map, this, b >>>= 1, subtasks, transformer, action)).fork();
5629                  }
5630                  U u;
5631                  while (advance() != null) {
5632                      if ((u = transformer.apply((K)nextKey)) != null)
5633                          action.apply(u);
5634                  }
5116 –                tryComplete();
5635              } catch (Throwable ex) {
5636                  return tryCompleteComputation(ex);
5637              }
5638 +            tryComplete(subtasks);
5639              return false;
5640          }
5641      }
5642  
5643      @SuppressWarnings("serial") static final class ForEachTransformedValueTask<K,V,U>
5644 <        extends BulkTask<K,V,Void> {
5644 >        extends BulkAction<K,V,Void> {
5645          final Fun<? super V, ? extends U> transformer;
5646          final Action<U> action;
5647          ForEachTransformedValueTask
5648 <            (ConcurrentHashMapV8<K,V> m,
5648 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5649 >             ForEachTransformedValueTask<K,V,U> nextTask,
5650               Fun<? super V, ? extends U> transformer,
5651               Action<U> action) {
5652 <            super(m);
5652 >            super(m, p, b, nextTask);
5653              this.transformer = transformer;
5654              this.action = action;
5655  
5656          }
5137 –        ForEachTransformedValueTask
5138 –            (BulkTask<K,V,?> p, int b,
5139 –             Fun<? super V, ? extends U> transformer,
5140 –             Action<U> action) {
5141 –            super(p, b);
5142 –            this.transformer = transformer;
5143 –            this.action = action;
5144 –        }
5657          @SuppressWarnings("unchecked") public final boolean exec() {
5658              final Fun<? super V, ? extends U> transformer =
5659                  this.transformer;
5660              final Action<U> action = this.action;
5661              if (transformer == null || action == null)
5662                  return abortOnNullFunction();
5663 +            ForEachTransformedValueTask<K,V,U> subtasks = null;
5664              try {
5665                  int b = batch(), c;
5666                  while (b > 1 && baseIndex != baseLimit) {
5667                      do {} while (!casPending(c = pending, c+1));
5668 <                    new ForEachTransformedValueTask<K,V,U>
5669 <                        (this, b >>>= 1, transformer, action).fork();
5668 >                    (subtasks = new ForEachTransformedValueTask<K,V,U>
5669 >                     (map, this, b >>>= 1, subtasks, transformer, action)).fork();
5670                  }
5671                  Object v; U u;
5672                  while ((v = advance()) != null) {
5673                      if ((u = transformer.apply((V)v)) != null)
5674                          action.apply(u);
5675                  }
5163 –                tryComplete();
5676              } catch (Throwable ex) {
5677                  return tryCompleteComputation(ex);
5678              }
5679 +            tryComplete(subtasks);
5680              return false;
5681          }
5682      }
5683  
5684      @SuppressWarnings("serial") static final class ForEachTransformedEntryTask<K,V,U>
5685 <        extends BulkTask<K,V,Void> {
5685 >        extends BulkAction<K,V,Void> {
5686          final Fun<Map.Entry<K,V>, ? extends U> transformer;
5687          final Action<U> action;
5688          ForEachTransformedEntryTask
5689 <            (ConcurrentHashMapV8<K,V> m,
5689 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5690 >             ForEachTransformedEntryTask<K,V,U> nextTask,
5691               Fun<Map.Entry<K,V>, ? extends U> transformer,
5692               Action<U> action) {
5693 <            super(m);
5693 >            super(m, p, b, nextTask);
5694              this.transformer = transformer;
5695              this.action = action;
5696  
5697          }
5184 –        ForEachTransformedEntryTask
5185 –            (BulkTask<K,V,?> p, int b,
5186 –             Fun<Map.Entry<K,V>, ? extends U> transformer,
5187 –             Action<U> action) {
5188 –            super(p, b);
5189 –            this.transformer = transformer;
5190 –            this.action = action;
5191 –        }
5698          @SuppressWarnings("unchecked") public final boolean exec() {
5699              final Fun<Map.Entry<K,V>, ? extends U> transformer =
5700                  this.transformer;
5701              final Action<U> action = this.action;
5702              if (transformer == null || action == null)
5703                  return abortOnNullFunction();
5704 +            ForEachTransformedEntryTask<K,V,U> subtasks = null;
5705              try {
5706                  int b = batch(), c;
5707                  while (b > 1 && baseIndex != baseLimit) {
5708                      do {} while (!casPending(c = pending, c+1));
5709 <                    new ForEachTransformedEntryTask<K,V,U>
5710 <                        (this, b >>>= 1, transformer, action).fork();
5709 >                    (subtasks = new ForEachTransformedEntryTask<K,V,U>
5710 >                     (map, this, b >>>= 1, subtasks, transformer, action)).fork();
5711                  }
5712                  Object v; U u;
5713                  while ((v = advance()) != null) {
5714                      if ((u = transformer.apply(entryFor((K)nextKey, (V)v))) != null)
5715                          action.apply(u);
5716                  }
5210 –                tryComplete();
5717              } catch (Throwable ex) {
5718                  return tryCompleteComputation(ex);
5719              }
5720 +            tryComplete(subtasks);
5721              return false;
5722          }
5723      }
5724  
5725      @SuppressWarnings("serial") static final class ForEachTransformedMappingTask<K,V,U>
5726 <        extends BulkTask<K,V,Void> {
5726 >        extends BulkAction<K,V,Void> {
5727          final BiFun<? super K, ? super V, ? extends U> transformer;
5728          final Action<U> action;
5729          ForEachTransformedMappingTask
5730 <            (ConcurrentHashMapV8<K,V> m,
5730 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5731 >             ForEachTransformedMappingTask<K,V,U> nextTask,
5732               BiFun<? super K, ? super V, ? extends U> transformer,
5733               Action<U> action) {
5734 <            super(m);
5734 >            super(m, p, b, nextTask);
5735              this.transformer = transformer;
5736              this.action = action;
5737  
5738          }
5231 –        ForEachTransformedMappingTask
5232 –            (BulkTask<K,V,?> p, int b,
5233 –             BiFun<? super K, ? super V, ? extends U> transformer,
5234 –             Action<U> action) {
5235 –            super(p, b);
5236 –            this.transformer = transformer;
5237 –            this.action = action;
5238 –        }
5739          @SuppressWarnings("unchecked") public final boolean exec() {
5740              final BiFun<? super K, ? super V, ? extends U> transformer =
5741                  this.transformer;
5742              final Action<U> action = this.action;
5743              if (transformer == null || action == null)
5744                  return abortOnNullFunction();
5745 +            ForEachTransformedMappingTask<K,V,U> subtasks = null;
5746              try {
5747                  int b = batch(), c;
5748                  while (b > 1 && baseIndex != baseLimit) {
5749                      do {} while (!casPending(c = pending, c+1));
5750 <                    new ForEachTransformedMappingTask<K,V,U>
5751 <                        (this, b >>>= 1, transformer, action).fork();
5750 >                    (subtasks = new ForEachTransformedMappingTask<K,V,U>
5751 >                     (map, this, b >>>= 1, subtasks, transformer, action)).fork();
5752                  }
5753                  Object v; U u;
5754                  while ((v = advance()) != null) {
5755                      if ((u = transformer.apply((K)nextKey, (V)v)) != null)
5756                          action.apply(u);
5757                  }
5257 –                tryComplete();
5758              } catch (Throwable ex) {
5759                  return tryCompleteComputation(ex);
5760              }
5761 +            tryComplete(subtasks);
5762              return false;
5763          }
5764      }
5765  
5766      @SuppressWarnings("serial") static final class SearchKeysTask<K,V,U>
5767 <        extends BulkTask<K,V,U> {
5767 >        extends BulkAction<K,V,U> {
5768          final Fun<? super K, ? extends U> searchFunction;
5769          final AtomicReference<U> result;
5770          SearchKeysTask
5771 <            (ConcurrentHashMapV8<K,V> m,
5772 <             Fun<? super K, ? extends U> searchFunction,
5272 <             AtomicReference<U> result) {
5273 <            super(m);
5274 <            this.searchFunction = searchFunction; this.result = result;
5275 <        }
5276 <        SearchKeysTask
5277 <            (BulkTask<K,V,?> p, int b,
5771 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5772 >             SearchKeysTask<K,V,U> nextTask,
5773               Fun<? super K, ? extends U> searchFunction,
5774               AtomicReference<U> result) {
5775 <            super(p, b);
5775 >            super(m, p, b, nextTask);
5776              this.searchFunction = searchFunction; this.result = result;
5777          }
5778          @SuppressWarnings("unchecked") public final boolean exec() {
# Line 5286 | Line 5781 | public class ConcurrentHashMapV8<K, V>
5781                  this.searchFunction;
5782              if (searchFunction == null || result == null)
5783                  return abortOnNullFunction();
5784 +            SearchKeysTask<K,V,U> subtasks = null;
5785              try {
5786                  int b = batch(), c;
5787                  while (b > 1 && baseIndex != baseLimit && result.get() == null) {
5788                      do {} while (!casPending(c = pending, c+1));
5789 <                    new SearchKeysTask<K,V,U>(this, b >>>= 1,
5790 <                                              searchFunction, result).fork();
5789 >                    (subtasks = new SearchKeysTask<K,V,U>
5790 >                     (map, this, b >>>= 1, subtasks, searchFunction, result)).fork();
5791                  }
5792                  U u;
5793                  while (result.get() == null && advance() != null) {
# Line 5301 | Line 5797 | public class ConcurrentHashMapV8<K, V>
5797                          break;
5798                      }
5799                  }
5304 –                tryComplete();
5800              } catch (Throwable ex) {
5801                  return tryCompleteComputation(ex);
5802              }
5803 +            tryComplete(subtasks);
5804              return false;
5805          }
5806          public final U getRawResult() { return result.get(); }
5807      }
5808  
5809      @SuppressWarnings("serial") static final class SearchValuesTask<K,V,U>
5810 <        extends BulkTask<K,V,U> {
5810 >        extends BulkAction<K,V,U> {
5811          final Fun<? super V, ? extends U> searchFunction;
5812          final AtomicReference<U> result;
5813          SearchValuesTask
5814 <            (ConcurrentHashMapV8<K,V> m,
5815 <             Fun<? super V, ? extends U> searchFunction,
5320 <             AtomicReference<U> result) {
5321 <            super(m);
5322 <            this.searchFunction = searchFunction; this.result = result;
5323 <        }
5324 <        SearchValuesTask
5325 <            (BulkTask<K,V,?> p, int b,
5814 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5815 >             SearchValuesTask<K,V,U> nextTask,
5816               Fun<? super V, ? extends U> searchFunction,
5817               AtomicReference<U> result) {
5818 <            super(p, b);
5818 >            super(m, p, b, nextTask);
5819              this.searchFunction = searchFunction; this.result = result;
5820          }
5821          @SuppressWarnings("unchecked") public final boolean exec() {
# Line 5334 | Line 5824 | public class ConcurrentHashMapV8<K, V>
5824                  this.searchFunction;
5825              if (searchFunction == null || result == null)
5826                  return abortOnNullFunction();
5827 +            SearchValuesTask<K,V,U> subtasks = null;
5828              try {
5829                  int b = batch(), c;
5830                  while (b > 1 && baseIndex != baseLimit && result.get() == null) {
5831                      do {} while (!casPending(c = pending, c+1));
5832 <                    new SearchValuesTask<K,V,U>(this, b >>>= 1,
5833 <                                                searchFunction, result).fork();
5832 >                    (subtasks = new SearchValuesTask<K,V,U>
5833 >                     (map, this, b >>>= 1, subtasks, searchFunction, result)).fork();
5834                  }
5835                  Object v; U u;
5836                  while (result.get() == null && (v = advance()) != null) {
# Line 5349 | Line 5840 | public class ConcurrentHashMapV8<K, V>
5840                          break;
5841                      }
5842                  }
5352 –                tryComplete();
5843              } catch (Throwable ex) {
5844                  return tryCompleteComputation(ex);
5845              }
5846 +            tryComplete(subtasks);
5847              return false;
5848          }
5849          public final U getRawResult() { return result.get(); }
5850      }
5851  
5852      @SuppressWarnings("serial") static final class SearchEntriesTask<K,V,U>
5853 <        extends BulkTask<K,V,U> {
5853 >        extends BulkAction<K,V,U> {
5854          final Fun<Entry<K,V>, ? extends U> searchFunction;
5855          final AtomicReference<U> result;
5856          SearchEntriesTask
5857 <            (ConcurrentHashMapV8<K,V> m,
5858 <             Fun<Entry<K,V>, ? extends U> searchFunction,
5368 <             AtomicReference<U> result) {
5369 <            super(m);
5370 <            this.searchFunction = searchFunction; this.result = result;
5371 <        }
5372 <        SearchEntriesTask
5373 <            (BulkTask<K,V,?> p, int b,
5857 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5858 >             SearchEntriesTask<K,V,U> nextTask,
5859               Fun<Entry<K,V>, ? extends U> searchFunction,
5860               AtomicReference<U> result) {
5861 <            super(p, b);
5861 >            super(m, p, b, nextTask);
5862              this.searchFunction = searchFunction; this.result = result;
5863          }
5864          @SuppressWarnings("unchecked") public final boolean exec() {
# Line 5382 | Line 5867 | public class ConcurrentHashMapV8<K, V>
5867                  this.searchFunction;
5868              if (searchFunction == null || result == null)
5869                  return abortOnNullFunction();
5870 +            SearchEntriesTask<K,V,U> subtasks = null;
5871              try {
5872                  int b = batch(), c;
5873                  while (b > 1 && baseIndex != baseLimit && result.get() == null) {
5874                      do {} while (!casPending(c = pending, c+1));
5875 <                    new SearchEntriesTask<K,V,U>(this, b >>>= 1,
5876 <                                                 searchFunction, result).fork();
5875 >                    (subtasks = new SearchEntriesTask<K,V,U>
5876 >                     (map, this, b >>>= 1, subtasks, searchFunction, result)).fork();
5877                  }
5878                  Object v; U u;
5879                  while (result.get() == null && (v = advance()) != null) {
# Line 5397 | Line 5883 | public class ConcurrentHashMapV8<K, V>
5883                          break;
5884                      }
5885                  }
5400 –                tryComplete();
5886              } catch (Throwable ex) {
5887                  return tryCompleteComputation(ex);
5888              }
5889 +            tryComplete(subtasks);
5890              return false;
5891          }
5892          public final U getRawResult() { return result.get(); }
5893      }
5894  
5895      @SuppressWarnings("serial") static final class SearchMappingsTask<K,V,U>
5896 <        extends BulkTask<K,V,U> {
5896 >        extends BulkAction<K,V,U> {
5897          final BiFun<? super K, ? super V, ? extends U> searchFunction;
5898          final AtomicReference<U> result;
5899          SearchMappingsTask
5900 <            (ConcurrentHashMapV8<K,V> m,
5901 <             BiFun<? super K, ? super V, ? extends U> searchFunction,
5416 <             AtomicReference<U> result) {
5417 <            super(m);
5418 <            this.searchFunction = searchFunction; this.result = result;
5419 <        }
5420 <        SearchMappingsTask
5421 <            (BulkTask<K,V,?> p, int b,
5900 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5901 >             SearchMappingsTask<K,V,U> nextTask,
5902               BiFun<? super K, ? super V, ? extends U> searchFunction,
5903               AtomicReference<U> result) {
5904 <            super(p, b);
5904 >            super(m, p, b, nextTask);
5905              this.searchFunction = searchFunction; this.result = result;
5906          }
5907          @SuppressWarnings("unchecked") public final boolean exec() {
# Line 5430 | Line 5910 | public class ConcurrentHashMapV8<K, V>
5910                  this.searchFunction;
5911              if (searchFunction == null || result == null)
5912                  return abortOnNullFunction();
5913 +            SearchMappingsTask<K,V,U> subtasks = null;
5914              try {
5915                  int b = batch(), c;
5916                  while (b > 1 && baseIndex != baseLimit && result.get() == null) {
5917                      do {} while (!casPending(c = pending, c+1));
5918 <                    new SearchMappingsTask<K,V,U>(this, b >>>= 1,
5919 <                                                  searchFunction, result).fork();
5918 >                    (subtasks = new SearchMappingsTask<K,V,U>
5919 >                     (map, this, b >>>= 1, subtasks, searchFunction, result)).fork();
5920                  }
5921                  Object v; U u;
5922                  while (result.get() == null && (v = advance()) != null) {
# Line 5445 | Line 5926 | public class ConcurrentHashMapV8<K, V>
5926                          break;
5927                      }
5928                  }
5448 –                tryComplete();
5929              } catch (Throwable ex) {
5930                  return tryCompleteComputation(ex);
5931              }
5932 +            tryComplete(subtasks);
5933              return false;
5934          }
5935          public final U getRawResult() { return result.get(); }
# Line 5460 | Line 5941 | public class ConcurrentHashMapV8<K, V>
5941          K result;
5942          ReduceKeysTask<K,V> rights, nextRight;
5943          ReduceKeysTask
5944 <            (ConcurrentHashMapV8<K,V> m,
5464 <             BiFun<? super K, ? super K, ? extends K> reducer) {
5465 <            super(m);
5466 <            this.reducer = reducer;
5467 <        }
5468 <        ReduceKeysTask
5469 <            (BulkTask<K,V,?> p, int b,
5944 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
5945               ReduceKeysTask<K,V> nextRight,
5946               BiFun<? super K, ? super K, ? extends K> reducer) {
5947 <            super(p, b); this.nextRight = nextRight;
5947 >            super(m, p, b); this.nextRight = nextRight;
5948              this.reducer = reducer;
5949          }
5475 –
5950          @SuppressWarnings("unchecked") public final boolean exec() {
5951              final BiFun<? super K, ? super K, ? extends K> reducer =
5952                  this.reducer;
# Line 5482 | Line 5956 | public class ConcurrentHashMapV8<K, V>
5956                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
5957                      do {} while (!casPending(c = pending, c+1));
5958                      (rights = new ReduceKeysTask<K,V>
5959 <                     (this, b >>>= 1, rights, reducer)).fork();
5959 >                     (map, this, b >>>= 1, rights, reducer)).fork();
5960                  }
5961                  K r = null;
5962                  while (advance() != null) {
# Line 5495 | Line 5969 | public class ConcurrentHashMapV8<K, V>
5969                      if ((c = t.pending) == 0) {
5970                          for (s = t.rights; s != null; s = t.rights = s.nextRight) {
5971                              if ((sr = s.result) != null)
5972 <                                t.result = (tr = t.result) == null? sr : reducer.apply(tr, sr);
5972 >                                t.result = ((tr = t.result) == null) ? sr : reducer.apply(tr, sr);
5973                          }
5974                          if ((par = t.parent) == null ||
5975                              !(par instanceof ReduceKeysTask)) {
# Line 5510 | Line 5984 | public class ConcurrentHashMapV8<K, V>
5984              } catch (Throwable ex) {
5985                  return tryCompleteComputation(ex);
5986              }
5987 +            ReduceKeysTask<K,V> s = rights;
5988 +            if (s != null && !inForkJoinPool()) {
5989 +                do  {
5990 +                    if (s.tryUnfork())
5991 +                        s.exec();
5992 +                } while ((s = s.nextRight) != null);
5993 +            }
5994              return false;
5995          }
5996          public final K getRawResult() { return result; }
# Line 5521 | Line 6002 | public class ConcurrentHashMapV8<K, V>
6002          V result;
6003          ReduceValuesTask<K,V> rights, nextRight;
6004          ReduceValuesTask
6005 <            (ConcurrentHashMapV8<K,V> m,
5525 <             BiFun<? super V, ? super V, ? extends V> reducer) {
5526 <            super(m);
5527 <            this.reducer = reducer;
5528 <        }
5529 <        ReduceValuesTask
5530 <            (BulkTask<K,V,?> p, int b,
6005 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6006               ReduceValuesTask<K,V> nextRight,
6007               BiFun<? super V, ? super V, ? extends V> reducer) {
6008 <            super(p, b); this.nextRight = nextRight;
6008 >            super(m, p, b); this.nextRight = nextRight;
6009              this.reducer = reducer;
6010          }
5536 –
6011          @SuppressWarnings("unchecked") public final boolean exec() {
6012              final BiFun<? super V, ? super V, ? extends V> reducer =
6013                  this.reducer;
# Line 5543 | Line 6017 | public class ConcurrentHashMapV8<K, V>
6017                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6018                      do {} while (!casPending(c = pending, c+1));
6019                      (rights = new ReduceValuesTask<K,V>
6020 <                     (this, b >>>= 1, rights, reducer)).fork();
6020 >                     (map, this, b >>>= 1, rights, reducer)).fork();
6021                  }
6022                  V r = null;
6023                  Object v;
# Line 5557 | Line 6031 | public class ConcurrentHashMapV8<K, V>
6031                      if ((c = t.pending) == 0) {
6032                          for (s = t.rights; s != null; s = t.rights = s.nextRight) {
6033                              if ((sr = s.result) != null)
6034 <                                t.result = (tr = t.result) == null? sr : reducer.apply(tr, sr);
6034 >                                t.result = ((tr = t.result) == null) ? sr : reducer.apply(tr, sr);
6035                          }
6036                          if ((par = t.parent) == null ||
6037                              !(par instanceof ReduceValuesTask)) {
# Line 5572 | Line 6046 | public class ConcurrentHashMapV8<K, V>
6046              } catch (Throwable ex) {
6047                  return tryCompleteComputation(ex);
6048              }
6049 +            ReduceValuesTask<K,V> s = rights;
6050 +            if (s != null && !inForkJoinPool()) {
6051 +                do  {
6052 +                    if (s.tryUnfork())
6053 +                        s.exec();
6054 +                } while ((s = s.nextRight) != null);
6055 +            }
6056              return false;
6057          }
6058          public final V getRawResult() { return result; }
# Line 5583 | Line 6064 | public class ConcurrentHashMapV8<K, V>
6064          Map.Entry<K,V> result;
6065          ReduceEntriesTask<K,V> rights, nextRight;
6066          ReduceEntriesTask
6067 <            (ConcurrentHashMapV8<K,V> m,
5587 <             BiFun<Entry<K,V>, Map.Entry<K,V>, ? extends Map.Entry<K,V>> reducer) {
5588 <            super(m);
5589 <            this.reducer = reducer;
5590 <        }
5591 <        ReduceEntriesTask
5592 <            (BulkTask<K,V,?> p, int b,
6067 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6068               ReduceEntriesTask<K,V> nextRight,
6069 <             BiFun<Map.Entry<K,V>, Map.Entry<K,V>, ? extends Map.Entry<K,V>> reducer) {
6070 <            super(p, b); this.nextRight = nextRight;
6069 >             BiFun<Entry<K,V>, Map.Entry<K,V>, ? extends Map.Entry<K,V>> reducer) {
6070 >            super(m, p, b); this.nextRight = nextRight;
6071              this.reducer = reducer;
6072          }
5598 –
6073          @SuppressWarnings("unchecked") public final boolean exec() {
6074              final BiFun<Map.Entry<K,V>, Map.Entry<K,V>, ? extends Map.Entry<K,V>> reducer =
6075                  this.reducer;
# Line 5605 | Line 6079 | public class ConcurrentHashMapV8<K, V>
6079                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6080                      do {} while (!casPending(c = pending, c+1));
6081                      (rights = new ReduceEntriesTask<K,V>
6082 <                     (this, b >>>= 1, rights, reducer)).fork();
6082 >                     (map, this, b >>>= 1, rights, reducer)).fork();
6083                  }
6084                  Map.Entry<K,V> r = null;
6085                  Object v;
# Line 5619 | Line 6093 | public class ConcurrentHashMapV8<K, V>
6093                      if ((c = t.pending) == 0) {
6094                          for (s = t.rights; s != null; s = t.rights = s.nextRight) {
6095                              if ((sr = s.result) != null)
6096 <                                t.result = (tr = t.result) == null? sr : reducer.apply(tr, sr);
6096 >                                t.result = ((tr = t.result) == null) ? sr : reducer.apply(tr, sr);
6097                          }
6098                          if ((par = t.parent) == null ||
6099                              !(par instanceof ReduceEntriesTask)) {
# Line 5634 | Line 6108 | public class ConcurrentHashMapV8<K, V>
6108              } catch (Throwable ex) {
6109                  return tryCompleteComputation(ex);
6110              }
6111 +            ReduceEntriesTask<K,V> s = rights;
6112 +            if (s != null && !inForkJoinPool()) {
6113 +                do  {
6114 +                    if (s.tryUnfork())
6115 +                        s.exec();
6116 +                } while ((s = s.nextRight) != null);
6117 +            }
6118              return false;
6119          }
6120          public final Map.Entry<K,V> getRawResult() { return result; }
# Line 5646 | Line 6127 | public class ConcurrentHashMapV8<K, V>
6127          U result;
6128          MapReduceKeysTask<K,V,U> rights, nextRight;
6129          MapReduceKeysTask
6130 <            (ConcurrentHashMapV8<K,V> m,
5650 <             Fun<? super K, ? extends U> transformer,
5651 <             BiFun<? super U, ? super U, ? extends U> reducer) {
5652 <            super(m);
5653 <            this.transformer = transformer;
5654 <            this.reducer = reducer;
5655 <        }
5656 <        MapReduceKeysTask
5657 <            (BulkTask<K,V,?> p, int b,
6130 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6131               MapReduceKeysTask<K,V,U> nextRight,
6132               Fun<? super K, ? extends U> transformer,
6133               BiFun<? super U, ? super U, ? extends U> reducer) {
6134 <            super(p, b); this.nextRight = nextRight;
6134 >            super(m, p, b); this.nextRight = nextRight;
6135              this.transformer = transformer;
6136              this.reducer = reducer;
6137          }
# Line 5673 | Line 6146 | public class ConcurrentHashMapV8<K, V>
6146                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6147                      do {} while (!casPending(c = pending, c+1));
6148                      (rights = new MapReduceKeysTask<K,V,U>
6149 <                     (this, b >>>= 1, rights, transformer, reducer)).fork();
6149 >                     (map, this, b >>>= 1, rights, transformer, reducer)).fork();
6150                  }
6151                  U r = null, u;
6152                  while (advance() != null) {
# Line 5686 | Line 6159 | public class ConcurrentHashMapV8<K, V>
6159                      if ((c = t.pending) == 0) {
6160                          for (s = t.rights; s != null; s = t.rights = s.nextRight) {
6161                              if ((sr = s.result) != null)
6162 <                                t.result = (tr = t.result) == null? sr : reducer.apply(tr, sr);
6162 >                                t.result = ((tr = t.result) == null) ? sr : reducer.apply(tr, sr);
6163                          }
6164                          if ((par = t.parent) == null ||
6165                              !(par instanceof MapReduceKeysTask)) {
# Line 5701 | Line 6174 | public class ConcurrentHashMapV8<K, V>
6174              } catch (Throwable ex) {
6175                  return tryCompleteComputation(ex);
6176              }
6177 +            MapReduceKeysTask<K,V,U> s = rights;
6178 +            if (s != null && !inForkJoinPool()) {
6179 +                do  {
6180 +                    if (s.tryUnfork())
6181 +                        s.exec();
6182 +                } while ((s = s.nextRight) != null);
6183 +            }
6184              return false;
6185          }
6186          public final U getRawResult() { return result; }
# Line 5713 | Line 6193 | public class ConcurrentHashMapV8<K, V>
6193          U result;
6194          MapReduceValuesTask<K,V,U> rights, nextRight;
6195          MapReduceValuesTask
6196 <            (ConcurrentHashMapV8<K,V> m,
5717 <             Fun<? super V, ? extends U> transformer,
5718 <             BiFun<? super U, ? super U, ? extends U> reducer) {
5719 <            super(m);
5720 <            this.transformer = transformer;
5721 <            this.reducer = reducer;
5722 <        }
5723 <        MapReduceValuesTask
5724 <            (BulkTask<K,V,?> p, int b,
6196 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6197               MapReduceValuesTask<K,V,U> nextRight,
6198               Fun<? super V, ? extends U> transformer,
6199               BiFun<? super U, ? super U, ? extends U> reducer) {
6200 <            super(p, b); this.nextRight = nextRight;
6200 >            super(m, p, b); this.nextRight = nextRight;
6201              this.transformer = transformer;
6202              this.reducer = reducer;
6203          }
# Line 5740 | Line 6212 | public class ConcurrentHashMapV8<K, V>
6212                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6213                      do {} while (!casPending(c = pending, c+1));
6214                      (rights = new MapReduceValuesTask<K,V,U>
6215 <                     (this, b >>>= 1, rights, transformer, reducer)).fork();
6215 >                     (map, this, b >>>= 1, rights, transformer, reducer)).fork();
6216                  }
6217                  U r = null, u;
6218                  Object v;
# Line 5754 | Line 6226 | public class ConcurrentHashMapV8<K, V>
6226                      if ((c = t.pending) == 0) {
6227                          for (s = t.rights; s != null; s = t.rights = s.nextRight) {
6228                              if ((sr = s.result) != null)
6229 <                                t.result = (tr = t.result) == null? sr : reducer.apply(tr, sr);
6229 >                                t.result = ((tr = t.result) == null) ? sr : reducer.apply(tr, sr);
6230                          }
6231                          if ((par = t.parent) == null ||
6232                              !(par instanceof MapReduceValuesTask)) {
# Line 5769 | Line 6241 | public class ConcurrentHashMapV8<K, V>
6241              } catch (Throwable ex) {
6242                  return tryCompleteComputation(ex);
6243              }
6244 +            MapReduceValuesTask<K,V,U> s = rights;
6245 +            if (s != null && !inForkJoinPool()) {
6246 +                do  {
6247 +                    if (s.tryUnfork())
6248 +                        s.exec();
6249 +                } while ((s = s.nextRight) != null);
6250 +            }
6251              return false;
6252          }
6253          public final U getRawResult() { return result; }
# Line 5781 | Line 6260 | public class ConcurrentHashMapV8<K, V>
6260          U result;
6261          MapReduceEntriesTask<K,V,U> rights, nextRight;
6262          MapReduceEntriesTask
6263 <            (ConcurrentHashMapV8<K,V> m,
5785 <             Fun<Map.Entry<K,V>, ? extends U> transformer,
5786 <             BiFun<? super U, ? super U, ? extends U> reducer) {
5787 <            super(m);
5788 <            this.transformer = transformer;
5789 <            this.reducer = reducer;
5790 <        }
5791 <        MapReduceEntriesTask
5792 <            (BulkTask<K,V,?> p, int b,
6263 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6264               MapReduceEntriesTask<K,V,U> nextRight,
6265               Fun<Map.Entry<K,V>, ? extends U> transformer,
6266               BiFun<? super U, ? super U, ? extends U> reducer) {
6267 <            super(p, b); this.nextRight = nextRight;
6267 >            super(m, p, b); this.nextRight = nextRight;
6268              this.transformer = transformer;
6269              this.reducer = reducer;
6270          }
# Line 5808 | Line 6279 | public class ConcurrentHashMapV8<K, V>
6279                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6280                      do {} while (!casPending(c = pending, c+1));
6281                      (rights = new MapReduceEntriesTask<K,V,U>
6282 <                     (this, b >>>= 1, rights, transformer, reducer)).fork();
6282 >                     (map, this, b >>>= 1, rights, transformer, reducer)).fork();
6283                  }
6284                  U r = null, u;
6285                  Object v;
# Line 5822 | Line 6293 | public class ConcurrentHashMapV8<K, V>
6293                      if ((c = t.pending) == 0) {
6294                          for (s = t.rights; s != null; s = t.rights = s.nextRight) {
6295                              if ((sr = s.result) != null)
6296 <                                t.result = (tr = t.result) == null? sr : reducer.apply(tr, sr);
6296 >                                t.result = ((tr = t.result) == null) ? sr : reducer.apply(tr, sr);
6297                          }
6298                          if ((par = t.parent) == null ||
6299                              !(par instanceof MapReduceEntriesTask)) {
# Line 5837 | Line 6308 | public class ConcurrentHashMapV8<K, V>
6308              } catch (Throwable ex) {
6309                  return tryCompleteComputation(ex);
6310              }
6311 +            MapReduceEntriesTask<K,V,U> s = rights;
6312 +            if (s != null && !inForkJoinPool()) {
6313 +                do  {
6314 +                    if (s.tryUnfork())
6315 +                        s.exec();
6316 +                } while ((s = s.nextRight) != null);
6317 +            }
6318              return false;
6319          }
6320          public final U getRawResult() { return result; }
# Line 5849 | Line 6327 | public class ConcurrentHashMapV8<K, V>
6327          U result;
6328          MapReduceMappingsTask<K,V,U> rights, nextRight;
6329          MapReduceMappingsTask
6330 <            (ConcurrentHashMapV8<K,V> m,
5853 <             BiFun<? super K, ? super V, ? extends U> transformer,
5854 <             BiFun<? super U, ? super U, ? extends U> reducer) {
5855 <            super(m);
5856 <            this.transformer = transformer;
5857 <            this.reducer = reducer;
5858 <        }
5859 <        MapReduceMappingsTask
5860 <            (BulkTask<K,V,?> p, int b,
6330 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6331               MapReduceMappingsTask<K,V,U> nextRight,
6332               BiFun<? super K, ? super V, ? extends U> transformer,
6333               BiFun<? super U, ? super U, ? extends U> reducer) {
6334 <            super(p, b); this.nextRight = nextRight;
6334 >            super(m, p, b); this.nextRight = nextRight;
6335              this.transformer = transformer;
6336              this.reducer = reducer;
6337          }
# Line 5876 | Line 6346 | public class ConcurrentHashMapV8<K, V>
6346                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6347                      do {} while (!casPending(c = pending, c+1));
6348                      (rights = new MapReduceMappingsTask<K,V,U>
6349 <                     (this, b >>>= 1, rights, transformer, reducer)).fork();
6349 >                     (map, this, b >>>= 1, rights, transformer, reducer)).fork();
6350                  }
6351                  U r = null, u;
6352                  Object v;
# Line 5890 | Line 6360 | public class ConcurrentHashMapV8<K, V>
6360                      if ((c = t.pending) == 0) {
6361                          for (s = t.rights; s != null; s = t.rights = s.nextRight) {
6362                              if ((sr = s.result) != null)
6363 <                                t.result = (tr = t.result) == null? sr : reducer.apply(tr, sr);
6363 >                                t.result = ((tr = t.result) == null) ? sr : reducer.apply(tr, sr);
6364                          }
6365                          if ((par = t.parent) == null ||
6366                              !(par instanceof MapReduceMappingsTask)) {
# Line 5905 | Line 6375 | public class ConcurrentHashMapV8<K, V>
6375              } catch (Throwable ex) {
6376                  return tryCompleteComputation(ex);
6377              }
6378 +            MapReduceMappingsTask<K,V,U> s = rights;
6379 +            if (s != null && !inForkJoinPool()) {
6380 +                do  {
6381 +                    if (s.tryUnfork())
6382 +                        s.exec();
6383 +                } while ((s = s.nextRight) != null);
6384 +            }
6385              return false;
6386          }
6387          public final U getRawResult() { return result; }
# Line 5918 | Line 6395 | public class ConcurrentHashMapV8<K, V>
6395          double result;
6396          MapReduceKeysToDoubleTask<K,V> rights, nextRight;
6397          MapReduceKeysToDoubleTask
6398 <            (ConcurrentHashMapV8<K,V> m,
5922 <             ObjectToDouble<? super K> transformer,
5923 <             double basis,
5924 <             DoubleByDoubleToDouble reducer) {
5925 <            super(m);
5926 <            this.transformer = transformer;
5927 <            this.basis = basis; this.reducer = reducer;
5928 <        }
5929 <        MapReduceKeysToDoubleTask
5930 <            (BulkTask<K,V,?> p, int b,
6398 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6399               MapReduceKeysToDoubleTask<K,V> nextRight,
6400               ObjectToDouble<? super K> transformer,
6401               double basis,
6402               DoubleByDoubleToDouble reducer) {
6403 <            super(p, b); this.nextRight = nextRight;
6403 >            super(m, p, b); this.nextRight = nextRight;
6404              this.transformer = transformer;
6405              this.basis = basis; this.reducer = reducer;
6406          }
# Line 5947 | Line 6415 | public class ConcurrentHashMapV8<K, V>
6415                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6416                      do {} while (!casPending(c = pending, c+1));
6417                      (rights = new MapReduceKeysToDoubleTask<K,V>
6418 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6418 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6419                  }
6420                  double r = id;
6421                  while (advance() != null)
# Line 5972 | Line 6440 | public class ConcurrentHashMapV8<K, V>
6440              } catch (Throwable ex) {
6441                  return tryCompleteComputation(ex);
6442              }
6443 +            MapReduceKeysToDoubleTask<K,V> s = rights;
6444 +            if (s != null && !inForkJoinPool()) {
6445 +                do  {
6446 +                    if (s.tryUnfork())
6447 +                        s.exec();
6448 +                } while ((s = s.nextRight) != null);
6449 +            }
6450              return false;
6451          }
6452          public final Double getRawResult() { return result; }
# Line 5985 | Line 6460 | public class ConcurrentHashMapV8<K, V>
6460          double result;
6461          MapReduceValuesToDoubleTask<K,V> rights, nextRight;
6462          MapReduceValuesToDoubleTask
6463 <            (ConcurrentHashMapV8<K,V> m,
5989 <             ObjectToDouble<? super V> transformer,
5990 <             double basis,
5991 <             DoubleByDoubleToDouble reducer) {
5992 <            super(m);
5993 <            this.transformer = transformer;
5994 <            this.basis = basis; this.reducer = reducer;
5995 <        }
5996 <        MapReduceValuesToDoubleTask
5997 <            (BulkTask<K,V,?> p, int b,
6463 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6464               MapReduceValuesToDoubleTask<K,V> nextRight,
6465               ObjectToDouble<? super V> transformer,
6466               double basis,
6467               DoubleByDoubleToDouble reducer) {
6468 <            super(p, b); this.nextRight = nextRight;
6468 >            super(m, p, b); this.nextRight = nextRight;
6469              this.transformer = transformer;
6470              this.basis = basis; this.reducer = reducer;
6471          }
# Line 6014 | Line 6480 | public class ConcurrentHashMapV8<K, V>
6480                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6481                      do {} while (!casPending(c = pending, c+1));
6482                      (rights = new MapReduceValuesToDoubleTask<K,V>
6483 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6483 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6484                  }
6485                  double r = id;
6486                  Object v;
# Line 6040 | Line 6506 | public class ConcurrentHashMapV8<K, V>
6506              } catch (Throwable ex) {
6507                  return tryCompleteComputation(ex);
6508              }
6509 +            MapReduceValuesToDoubleTask<K,V> s = rights;
6510 +            if (s != null && !inForkJoinPool()) {
6511 +                do  {
6512 +                    if (s.tryUnfork())
6513 +                        s.exec();
6514 +                } while ((s = s.nextRight) != null);
6515 +            }
6516              return false;
6517          }
6518          public final Double getRawResult() { return result; }
# Line 6053 | Line 6526 | public class ConcurrentHashMapV8<K, V>
6526          double result;
6527          MapReduceEntriesToDoubleTask<K,V> rights, nextRight;
6528          MapReduceEntriesToDoubleTask
6529 <            (ConcurrentHashMapV8<K,V> m,
6057 <             ObjectToDouble<Map.Entry<K,V>> transformer,
6058 <             double basis,
6059 <             DoubleByDoubleToDouble reducer) {
6060 <            super(m);
6061 <            this.transformer = transformer;
6062 <            this.basis = basis; this.reducer = reducer;
6063 <        }
6064 <        MapReduceEntriesToDoubleTask
6065 <            (BulkTask<K,V,?> p, int b,
6529 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6530               MapReduceEntriesToDoubleTask<K,V> nextRight,
6531               ObjectToDouble<Map.Entry<K,V>> transformer,
6532               double basis,
6533               DoubleByDoubleToDouble reducer) {
6534 <            super(p, b); this.nextRight = nextRight;
6534 >            super(m, p, b); this.nextRight = nextRight;
6535              this.transformer = transformer;
6536              this.basis = basis; this.reducer = reducer;
6537          }
# Line 6082 | Line 6546 | public class ConcurrentHashMapV8<K, V>
6546                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6547                      do {} while (!casPending(c = pending, c+1));
6548                      (rights = new MapReduceEntriesToDoubleTask<K,V>
6549 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6549 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6550                  }
6551                  double r = id;
6552                  Object v;
# Line 6108 | Line 6572 | public class ConcurrentHashMapV8<K, V>
6572              } catch (Throwable ex) {
6573                  return tryCompleteComputation(ex);
6574              }
6575 +            MapReduceEntriesToDoubleTask<K,V> s = rights;
6576 +            if (s != null && !inForkJoinPool()) {
6577 +                do  {
6578 +                    if (s.tryUnfork())
6579 +                        s.exec();
6580 +                } while ((s = s.nextRight) != null);
6581 +            }
6582              return false;
6583          }
6584          public final Double getRawResult() { return result; }
# Line 6121 | Line 6592 | public class ConcurrentHashMapV8<K, V>
6592          double result;
6593          MapReduceMappingsToDoubleTask<K,V> rights, nextRight;
6594          MapReduceMappingsToDoubleTask
6595 <            (ConcurrentHashMapV8<K,V> m,
6125 <             ObjectByObjectToDouble<? super K, ? super V> transformer,
6126 <             double basis,
6127 <             DoubleByDoubleToDouble reducer) {
6128 <            super(m);
6129 <            this.transformer = transformer;
6130 <            this.basis = basis; this.reducer = reducer;
6131 <        }
6132 <        MapReduceMappingsToDoubleTask
6133 <            (BulkTask<K,V,?> p, int b,
6595 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6596               MapReduceMappingsToDoubleTask<K,V> nextRight,
6597               ObjectByObjectToDouble<? super K, ? super V> transformer,
6598               double basis,
6599               DoubleByDoubleToDouble reducer) {
6600 <            super(p, b); this.nextRight = nextRight;
6600 >            super(m, p, b); this.nextRight = nextRight;
6601              this.transformer = transformer;
6602              this.basis = basis; this.reducer = reducer;
6603          }
# Line 6150 | Line 6612 | public class ConcurrentHashMapV8<K, V>
6612                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6613                      do {} while (!casPending(c = pending, c+1));
6614                      (rights = new MapReduceMappingsToDoubleTask<K,V>
6615 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6615 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6616                  }
6617                  double r = id;
6618                  Object v;
# Line 6176 | Line 6638 | public class ConcurrentHashMapV8<K, V>
6638              } catch (Throwable ex) {
6639                  return tryCompleteComputation(ex);
6640              }
6641 +            MapReduceMappingsToDoubleTask<K,V> s = rights;
6642 +            if (s != null && !inForkJoinPool()) {
6643 +                do  {
6644 +                    if (s.tryUnfork())
6645 +                        s.exec();
6646 +                } while ((s = s.nextRight) != null);
6647 +            }
6648              return false;
6649          }
6650          public final Double getRawResult() { return result; }
# Line 6189 | Line 6658 | public class ConcurrentHashMapV8<K, V>
6658          long result;
6659          MapReduceKeysToLongTask<K,V> rights, nextRight;
6660          MapReduceKeysToLongTask
6661 <            (ConcurrentHashMapV8<K,V> m,
6193 <             ObjectToLong<? super K> transformer,
6194 <             long basis,
6195 <             LongByLongToLong reducer) {
6196 <            super(m);
6197 <            this.transformer = transformer;
6198 <            this.basis = basis; this.reducer = reducer;
6199 <        }
6200 <        MapReduceKeysToLongTask
6201 <            (BulkTask<K,V,?> p, int b,
6661 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6662               MapReduceKeysToLongTask<K,V> nextRight,
6663               ObjectToLong<? super K> transformer,
6664               long basis,
6665               LongByLongToLong reducer) {
6666 <            super(p, b); this.nextRight = nextRight;
6666 >            super(m, p, b); this.nextRight = nextRight;
6667              this.transformer = transformer;
6668              this.basis = basis; this.reducer = reducer;
6669          }
# Line 6218 | Line 6678 | public class ConcurrentHashMapV8<K, V>
6678                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6679                      do {} while (!casPending(c = pending, c+1));
6680                      (rights = new MapReduceKeysToLongTask<K,V>
6681 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6681 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6682                  }
6683                  long r = id;
6684                  while (advance() != null)
# Line 6243 | Line 6703 | public class ConcurrentHashMapV8<K, V>
6703              } catch (Throwable ex) {
6704                  return tryCompleteComputation(ex);
6705              }
6706 +            MapReduceKeysToLongTask<K,V> s = rights;
6707 +            if (s != null && !inForkJoinPool()) {
6708 +                do  {
6709 +                    if (s.tryUnfork())
6710 +                        s.exec();
6711 +                } while ((s = s.nextRight) != null);
6712 +            }
6713              return false;
6714          }
6715          public final Long getRawResult() { return result; }
# Line 6256 | Line 6723 | public class ConcurrentHashMapV8<K, V>
6723          long result;
6724          MapReduceValuesToLongTask<K,V> rights, nextRight;
6725          MapReduceValuesToLongTask
6726 <            (ConcurrentHashMapV8<K,V> m,
6260 <             ObjectToLong<? super V> transformer,
6261 <             long basis,
6262 <             LongByLongToLong reducer) {
6263 <            super(m);
6264 <            this.transformer = transformer;
6265 <            this.basis = basis; this.reducer = reducer;
6266 <        }
6267 <        MapReduceValuesToLongTask
6268 <            (BulkTask<K,V,?> p, int b,
6726 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6727               MapReduceValuesToLongTask<K,V> nextRight,
6728               ObjectToLong<? super V> transformer,
6729               long basis,
6730               LongByLongToLong reducer) {
6731 <            super(p, b); this.nextRight = nextRight;
6731 >            super(m, p, b); this.nextRight = nextRight;
6732              this.transformer = transformer;
6733              this.basis = basis; this.reducer = reducer;
6734          }
# Line 6285 | Line 6743 | public class ConcurrentHashMapV8<K, V>
6743                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6744                      do {} while (!casPending(c = pending, c+1));
6745                      (rights = new MapReduceValuesToLongTask<K,V>
6746 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6746 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6747                  }
6748                  long r = id;
6749                  Object v;
# Line 6311 | Line 6769 | public class ConcurrentHashMapV8<K, V>
6769              } catch (Throwable ex) {
6770                  return tryCompleteComputation(ex);
6771              }
6772 +            MapReduceValuesToLongTask<K,V> s = rights;
6773 +            if (s != null && !inForkJoinPool()) {
6774 +                do  {
6775 +                    if (s.tryUnfork())
6776 +                        s.exec();
6777 +                } while ((s = s.nextRight) != null);
6778 +            }
6779              return false;
6780          }
6781          public final Long getRawResult() { return result; }
# Line 6324 | Line 6789 | public class ConcurrentHashMapV8<K, V>
6789          long result;
6790          MapReduceEntriesToLongTask<K,V> rights, nextRight;
6791          MapReduceEntriesToLongTask
6792 <            (ConcurrentHashMapV8<K,V> m,
6328 <             ObjectToLong<Map.Entry<K,V>> transformer,
6329 <             long basis,
6330 <             LongByLongToLong reducer) {
6331 <            super(m);
6332 <            this.transformer = transformer;
6333 <            this.basis = basis; this.reducer = reducer;
6334 <        }
6335 <        MapReduceEntriesToLongTask
6336 <            (BulkTask<K,V,?> p, int b,
6792 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6793               MapReduceEntriesToLongTask<K,V> nextRight,
6794               ObjectToLong<Map.Entry<K,V>> transformer,
6795               long basis,
6796               LongByLongToLong reducer) {
6797 <            super(p, b); this.nextRight = nextRight;
6797 >            super(m, p, b); this.nextRight = nextRight;
6798              this.transformer = transformer;
6799              this.basis = basis; this.reducer = reducer;
6800          }
# Line 6353 | Line 6809 | public class ConcurrentHashMapV8<K, V>
6809                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6810                      do {} while (!casPending(c = pending, c+1));
6811                      (rights = new MapReduceEntriesToLongTask<K,V>
6812 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6812 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6813                  }
6814                  long r = id;
6815                  Object v;
# Line 6379 | Line 6835 | public class ConcurrentHashMapV8<K, V>
6835              } catch (Throwable ex) {
6836                  return tryCompleteComputation(ex);
6837              }
6838 +            MapReduceEntriesToLongTask<K,V> s = rights;
6839 +            if (s != null && !inForkJoinPool()) {
6840 +                do  {
6841 +                    if (s.tryUnfork())
6842 +                        s.exec();
6843 +                } while ((s = s.nextRight) != null);
6844 +            }
6845              return false;
6846          }
6847          public final Long getRawResult() { return result; }
# Line 6392 | Line 6855 | public class ConcurrentHashMapV8<K, V>
6855          long result;
6856          MapReduceMappingsToLongTask<K,V> rights, nextRight;
6857          MapReduceMappingsToLongTask
6858 <            (ConcurrentHashMapV8<K,V> m,
6396 <             ObjectByObjectToLong<? super K, ? super V> transformer,
6397 <             long basis,
6398 <             LongByLongToLong reducer) {
6399 <            super(m);
6400 <            this.transformer = transformer;
6401 <            this.basis = basis; this.reducer = reducer;
6402 <        }
6403 <        MapReduceMappingsToLongTask
6404 <            (BulkTask<K,V,?> p, int b,
6858 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6859               MapReduceMappingsToLongTask<K,V> nextRight,
6860               ObjectByObjectToLong<? super K, ? super V> transformer,
6861               long basis,
6862               LongByLongToLong reducer) {
6863 <            super(p, b); this.nextRight = nextRight;
6863 >            super(m, p, b); this.nextRight = nextRight;
6864              this.transformer = transformer;
6865              this.basis = basis; this.reducer = reducer;
6866          }
# Line 6421 | Line 6875 | public class ConcurrentHashMapV8<K, V>
6875                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6876                      do {} while (!casPending(c = pending, c+1));
6877                      (rights = new MapReduceMappingsToLongTask<K,V>
6878 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6878 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6879                  }
6880                  long r = id;
6881                  Object v;
# Line 6447 | Line 6901 | public class ConcurrentHashMapV8<K, V>
6901              } catch (Throwable ex) {
6902                  return tryCompleteComputation(ex);
6903              }
6904 +            MapReduceMappingsToLongTask<K,V> s = rights;
6905 +            if (s != null && !inForkJoinPool()) {
6906 +                do  {
6907 +                    if (s.tryUnfork())
6908 +                        s.exec();
6909 +                } while ((s = s.nextRight) != null);
6910 +            }
6911              return false;
6912          }
6913          public final Long getRawResult() { return result; }
# Line 6460 | Line 6921 | public class ConcurrentHashMapV8<K, V>
6921          int result;
6922          MapReduceKeysToIntTask<K,V> rights, nextRight;
6923          MapReduceKeysToIntTask
6924 <            (ConcurrentHashMapV8<K,V> m,
6464 <             ObjectToInt<? super K> transformer,
6465 <             int basis,
6466 <             IntByIntToInt reducer) {
6467 <            super(m);
6468 <            this.transformer = transformer;
6469 <            this.basis = basis; this.reducer = reducer;
6470 <        }
6471 <        MapReduceKeysToIntTask
6472 <            (BulkTask<K,V,?> p, int b,
6924 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6925               MapReduceKeysToIntTask<K,V> nextRight,
6926               ObjectToInt<? super K> transformer,
6927               int basis,
6928               IntByIntToInt reducer) {
6929 <            super(p, b); this.nextRight = nextRight;
6929 >            super(m, p, b); this.nextRight = nextRight;
6930              this.transformer = transformer;
6931              this.basis = basis; this.reducer = reducer;
6932          }
# Line 6489 | Line 6941 | public class ConcurrentHashMapV8<K, V>
6941                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
6942                      do {} while (!casPending(c = pending, c+1));
6943                      (rights = new MapReduceKeysToIntTask<K,V>
6944 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
6944 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
6945                  }
6946                  int r = id;
6947                  while (advance() != null)
# Line 6514 | Line 6966 | public class ConcurrentHashMapV8<K, V>
6966              } catch (Throwable ex) {
6967                  return tryCompleteComputation(ex);
6968              }
6969 +            MapReduceKeysToIntTask<K,V> s = rights;
6970 +            if (s != null && !inForkJoinPool()) {
6971 +                do  {
6972 +                    if (s.tryUnfork())
6973 +                        s.exec();
6974 +                } while ((s = s.nextRight) != null);
6975 +            }
6976              return false;
6977          }
6978          public final Integer getRawResult() { return result; }
# Line 6527 | Line 6986 | public class ConcurrentHashMapV8<K, V>
6986          int result;
6987          MapReduceValuesToIntTask<K,V> rights, nextRight;
6988          MapReduceValuesToIntTask
6989 <            (ConcurrentHashMapV8<K,V> m,
6531 <             ObjectToInt<? super V> transformer,
6532 <             int basis,
6533 <             IntByIntToInt reducer) {
6534 <            super(m);
6535 <            this.transformer = transformer;
6536 <            this.basis = basis; this.reducer = reducer;
6537 <        }
6538 <        MapReduceValuesToIntTask
6539 <            (BulkTask<K,V,?> p, int b,
6989 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
6990               MapReduceValuesToIntTask<K,V> nextRight,
6991               ObjectToInt<? super V> transformer,
6992               int basis,
6993               IntByIntToInt reducer) {
6994 <            super(p, b); this.nextRight = nextRight;
6994 >            super(m, p, b); this.nextRight = nextRight;
6995              this.transformer = transformer;
6996              this.basis = basis; this.reducer = reducer;
6997          }
# Line 6556 | Line 7006 | public class ConcurrentHashMapV8<K, V>
7006                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
7007                      do {} while (!casPending(c = pending, c+1));
7008                      (rights = new MapReduceValuesToIntTask<K,V>
7009 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
7009 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
7010                  }
7011                  int r = id;
7012                  Object v;
# Line 6582 | Line 7032 | public class ConcurrentHashMapV8<K, V>
7032              } catch (Throwable ex) {
7033                  return tryCompleteComputation(ex);
7034              }
7035 +            MapReduceValuesToIntTask<K,V> s = rights;
7036 +            if (s != null && !inForkJoinPool()) {
7037 +                do  {
7038 +                    if (s.tryUnfork())
7039 +                        s.exec();
7040 +                } while ((s = s.nextRight) != null);
7041 +            }
7042              return false;
7043          }
7044          public final Integer getRawResult() { return result; }
# Line 6595 | Line 7052 | public class ConcurrentHashMapV8<K, V>
7052          int result;
7053          MapReduceEntriesToIntTask<K,V> rights, nextRight;
7054          MapReduceEntriesToIntTask
7055 <            (ConcurrentHashMapV8<K,V> m,
6599 <             ObjectToInt<Map.Entry<K,V>> transformer,
6600 <             int basis,
6601 <             IntByIntToInt reducer) {
6602 <            super(m);
6603 <            this.transformer = transformer;
6604 <            this.basis = basis; this.reducer = reducer;
6605 <        }
6606 <        MapReduceEntriesToIntTask
6607 <            (BulkTask<K,V,?> p, int b,
7055 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
7056               MapReduceEntriesToIntTask<K,V> nextRight,
7057               ObjectToInt<Map.Entry<K,V>> transformer,
7058               int basis,
7059               IntByIntToInt reducer) {
7060 <            super(p, b); this.nextRight = nextRight;
7060 >            super(m, p, b); this.nextRight = nextRight;
7061              this.transformer = transformer;
7062              this.basis = basis; this.reducer = reducer;
7063          }
# Line 6624 | Line 7072 | public class ConcurrentHashMapV8<K, V>
7072                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
7073                      do {} while (!casPending(c = pending, c+1));
7074                      (rights = new MapReduceEntriesToIntTask<K,V>
7075 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
7075 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
7076                  }
7077                  int r = id;
7078                  Object v;
# Line 6650 | Line 7098 | public class ConcurrentHashMapV8<K, V>
7098              } catch (Throwable ex) {
7099                  return tryCompleteComputation(ex);
7100              }
7101 +            MapReduceEntriesToIntTask<K,V> s = rights;
7102 +            if (s != null && !inForkJoinPool()) {
7103 +                do  {
7104 +                    if (s.tryUnfork())
7105 +                        s.exec();
7106 +                } while ((s = s.nextRight) != null);
7107 +            }
7108              return false;
7109          }
7110          public final Integer getRawResult() { return result; }
# Line 6663 | Line 7118 | public class ConcurrentHashMapV8<K, V>
7118          int result;
7119          MapReduceMappingsToIntTask<K,V> rights, nextRight;
7120          MapReduceMappingsToIntTask
7121 <            (ConcurrentHashMapV8<K,V> m,
7121 >            (ConcurrentHashMapV8<K,V> m, BulkTask<K,V,?> p, int b,
7122 >             MapReduceMappingsToIntTask<K,V> rights,
7123               ObjectByObjectToInt<? super K, ? super V> transformer,
7124               int basis,
7125               IntByIntToInt reducer) {
7126 <            super(m);
6671 <            this.transformer = transformer;
6672 <            this.basis = basis; this.reducer = reducer;
6673 <        }
6674 <        MapReduceMappingsToIntTask
6675 <            (BulkTask<K,V,?> p, int b,
6676 <             MapReduceMappingsToIntTask<K,V> nextRight,
6677 <             ObjectByObjectToInt<? super K, ? super V> transformer,
6678 <             int basis,
6679 <             IntByIntToInt reducer) {
6680 <            super(p, b); this.nextRight = nextRight;
7126 >            super(m, p, b); this.nextRight = nextRight;
7127              this.transformer = transformer;
7128              this.basis = basis; this.reducer = reducer;
7129          }
# Line 6692 | Line 7138 | public class ConcurrentHashMapV8<K, V>
7138                  for (int c, b = batch(); b > 1 && baseIndex != baseLimit;) {
7139                      do {} while (!casPending(c = pending, c+1));
7140                      (rights = new MapReduceMappingsToIntTask<K,V>
7141 <                     (this, b >>>= 1, rights, transformer, id, reducer)).fork();
7141 >                     (map, this, b >>>= 1, rights, transformer, id, reducer)).fork();
7142                  }
7143                  int r = id;
7144                  Object v;
# Line 6718 | Line 7164 | public class ConcurrentHashMapV8<K, V>
7164              } catch (Throwable ex) {
7165                  return tryCompleteComputation(ex);
7166              }
7167 +            MapReduceMappingsToIntTask<K,V> s = rights;
7168 +            if (s != null && !inForkJoinPool()) {
7169 +                do  {
7170 +                    if (s.tryUnfork())
7171 +                        s.exec();
7172 +                } while ((s = s.nextRight) != null);
7173 +            }
7174              return false;
7175          }
7176          public final Integer getRawResult() { return result; }
7177      }
7178  
6726 –
7179      // Unsafe mechanics
7180      private static final sun.misc.Unsafe UNSAFE;
7181      private static final long counterOffset;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines