ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/jsr166e/ConcurrentHashMapV8.java

Comparing jsr166/src/jsr166e/ConcurrentHashMapV8.java (file contents):
Revision 1.65 by jsr166, Sun Oct 21 02:37:58 2012 UTC vs.
Revision 1.77 by jsr166, Sun Nov 18 03:07:22 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 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.
#	Line 92 | Line 102 | import java.io.Serializable;
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 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
#	Line 2313 | 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
#	Line 2347 | Line 2456 | public class ConcurrentHashMapV8<K, V>
2456		}
2457
2458		public final void remove() {
2459	<	if (nextVal == null && last == null)
2460	<	advance();
2352	<	Node e = last;
2353	<	if (e == null)
2459	>	Object k = nextKey;
2460	>	if (k == null && (advance() == null || (k = nextKey) == null))
2461		throw new IllegalStateException();
2462	<	last = null;
2356	<	map.remove(e.key);
2462	>	map.internalReplace(k, null, null);
2463		}
2464
2465		public final boolean hasNext() {
#	Line 2457 | 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 2475 | 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 2506 | Line 2638 | public class ConcurrentHashMapV8<K, V>
2638
2639		/**
2640		* Returns the value to which the specified key is mapped,
2641	<	* or the gieven defaultValue if this map contains no mapping for the key.
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.
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		*/
#	Line 2650 | 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 2848 | 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
2852	<	* removal, which removes the corresponding mapping from this map,
2853	<	* via the {@code Iterator.remove}, {@code Set.remove},
2854	<	* {@code removeAll}, {@code retainAll}, and {@code clear}
2855	<	* operations.  It does not support the {@code add} or
2856	<	* {@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
2873	<	* supports element removal, which removes the corresponding
2874	<	* mapping from this map, via the {@code Iterator.remove},
2875	<	* {@code Collection.remove}, {@code removeAll},
2876	<	* {@code retainAll}, and {@code clear} operations.  It does not
2877	<	* support the {@code add} or {@code addAll} operations.
2878	<	*
2879	<	* <p>The view's {@code iterator} is a "weakly consistent" iterator
2880	<	* that will never throw {@link ConcurrentModificationException},
2881	<	* and guarantees to traverse elements as they existed upon
2882	<	* construction of the iterator, and may (but is not guaranteed to)
2883	<	* 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 2904 | 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 3045 | 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 3067 | 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 3090 | 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 3148 | Line 3278 | public class ConcurrentHashMapV8<K, V>
3278		}
3279		}
3280
3151	–	/* ----------------Views -------------- */
3152	–
3153	–	/**
3154	–	* Base class for views.
3155	–	*/
3156	–	static abstract class CHMView<K, V> {
3157	–	final ConcurrentHashMapV8<K, V> map;
3158	–	CHMView(ConcurrentHashMapV8<K, V> map)  { this.map = map; }
3159	–	public final int size()                 { return map.size(); }
3160	–	public final boolean isEmpty()          { return map.isEmpty(); }
3161	–	public final void clear()               { map.clear(); }
3162	–
3163	–	// implementations below rely on concrete classes supplying these
3164	–	abstract public Iterator<?> iterator();
3165	–	abstract public boolean contains(Object o);
3166	–	abstract public boolean remove(Object o);
3167	–
3168	–	private static final String oomeMsg = "Required array size too large";
3169	–
3170	–	public final Object[] toArray() {
3171	–	long sz = map.mappingCount();
3172	–	if (sz > (long)(MAX_ARRAY_SIZE))
3173	–	throw new OutOfMemoryError(oomeMsg);
3174	–	int n = (int)sz;
3175	–	Object[] r = new Object[n];
3176	–	int i = 0;
3177	–	Iterator<?> it = iterator();
3178	–	while (it.hasNext()) {
3179	–	if (i == n) {
3180	–	if (n >= MAX_ARRAY_SIZE)
3181	–	throw new OutOfMemoryError(oomeMsg);
3182	–	if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
3183	–	n = MAX_ARRAY_SIZE;
3184	–	else
3185	–	n += (n >>> 1) + 1;
3186	–	r = Arrays.copyOf(r, n);
3187	–	}
3188	–	r[i++] = it.next();
3189	–	}
3190	–	return (i == n) ? r : Arrays.copyOf(r, i);
3191	–	}
3192	–
3193	–	@SuppressWarnings("unchecked") public final <T> T[] toArray(T[] a) {
3194	–	long sz = map.mappingCount();
3195	–	if (sz > (long)(MAX_ARRAY_SIZE))
3196	–	throw new OutOfMemoryError(oomeMsg);
3197	–	int m = (int)sz;
3198	–	T[] r = (a.length >= m) ? a :
3199	–	(T[])java.lang.reflect.Array
3200	–	.newInstance(a.getClass().getComponentType(), m);
3201	–	int n = r.length;
3202	–	int i = 0;
3203	–	Iterator<?> it = iterator();
3204	–	while (it.hasNext()) {
3205	–	if (i == n) {
3206	–	if (n >= MAX_ARRAY_SIZE)
3207	–	throw new OutOfMemoryError(oomeMsg);
3208	–	if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
3209	–	n = MAX_ARRAY_SIZE;
3210	–	else
3211	–	n += (n >>> 1) + 1;
3212	–	r = Arrays.copyOf(r, n);
3213	–	}
3214	–	r[i++] = (T)it.next();
3215	–	}
3216	–	if (a == r && i < n) {
3217	–	r[i] = null; // null-terminate
3218	–	return r;
3219	–	}
3220	–	return (i == n) ? r : Arrays.copyOf(r, i);
3221	–	}
3222	–
3223	–	public final int hashCode() {
3224	–	int h = 0;
3225	–	for (Iterator<?> it = iterator(); it.hasNext();)
3226	–	h += it.next().hashCode();
3227	–	return h;
3228	–	}
3229	–
3230	–	public final String toString() {
3231	–	StringBuilder sb = new StringBuilder();
3232	–	sb.append('[');
3233	–	Iterator<?> it = iterator();
3234	–	if (it.hasNext()) {
3235	–	for (;;) {
3236	–	Object e = it.next();
3237	–	sb.append(e == this ? "(this Collection)" : e);
3238	–	if (!it.hasNext())
3239	–	break;
3240	–	sb.append(',').append(' ');
3241	–	}
3242	–	}
3243	–	return sb.append(']').toString();
3244	–	}
3245	–
3246	–	public final boolean containsAll(Collection<?> c) {
3247	–	if (c != this) {
3248	–	for (Iterator<?> it = c.iterator(); it.hasNext();) {
3249	–	Object e = it.next();
3250	–	if (e == null || !contains(e))
3251	–	return false;
3252	–	}
3253	–	}
3254	–	return true;
3255	–	}
3256	–
3257	–	public final boolean removeAll(Collection<?> c) {
3258	–	boolean modified = false;
3259	–	for (Iterator<?> it = iterator(); it.hasNext();) {
3260	–	if (c.contains(it.next())) {
3261	–	it.remove();
3262	–	modified = true;
3263	–	}
3264	–	}
3265	–	return modified;
3266	–	}
3267	–
3268	–	public final boolean retainAll(Collection<?> c) {
3269	–	boolean modified = false;
3270	–	for (Iterator<?> it = iterator(); it.hasNext();) {
3271	–	if (!c.contains(it.next())) {
3272	–	it.remove();
3273	–	modified = true;
3274	–	}
3275	–	}
3276	–	return modified;
3277	–	}
3278	–
3279	–	}
3280	–
3281	–	static final class KeySet<K,V> extends CHMView<K,V> implements Set<K> {
3282	–	KeySet(ConcurrentHashMapV8<K, V> map)  {
3283	–	super(map);
3284	–	}
3285	–	public final boolean contains(Object o) { return map.containsKey(o); }
3286	–	public final boolean remove(Object o)   { return map.remove(o) != null; }
3287	–	public final Iterator<K> iterator() {
3288	–	return new KeyIterator<K,V>(map);
3289	–	}
3290	–	public final boolean add(K e) {
3291	–	throw new UnsupportedOperationException();
3292	–	}
3293	–	public final boolean addAll(Collection<? extends K> c) {
3294	–	throw new UnsupportedOperationException();
3295	–	}
3296	–	public boolean equals(Object o) {
3297	–	Set<?> c;
3298	–	return ((o instanceof Set) &&
3299	–	((c = (Set<?>)o) == this ||
3300	–	(containsAll(c) && c.containsAll(this))));
3301	–	}
3302	–	}
3303	–
3304	–
3305	–	static final class Values<K,V> extends CHMView<K,V>
3306	–	implements Collection<V> {
3307	–	Values(ConcurrentHashMapV8<K, V> map)   { super(map); }
3308	–	public final boolean contains(Object o) { return map.containsValue(o); }
3309	–	public final boolean remove(Object o) {
3310	–	if (o != null) {
3311	–	Iterator<V> it = new ValueIterator<K,V>(map);
3312	–	while (it.hasNext()) {
3313	–	if (o.equals(it.next())) {
3314	–	it.remove();
3315	–	return true;
3316	–	}
3317	–	}
3318	–	}
3319	–	return false;
3320	–	}
3321	–	public final Iterator<V> iterator() {
3322	–	return new ValueIterator<K,V>(map);
3323	–	}
3324	–	public final boolean add(V e) {
3325	–	throw new UnsupportedOperationException();
3326	–	}
3327	–	public final boolean addAll(Collection<? extends V> c) {
3328	–	throw new UnsupportedOperationException();
3329	–	}
3330	–
3331	–	}
3332	–
3333	–	static final class EntrySet<K,V> extends CHMView<K,V>
3334	–	implements Set<Map.Entry<K,V>> {
3335	–	EntrySet(ConcurrentHashMapV8<K, V> map) { super(map); }
3336	–	public final boolean contains(Object o) {
3337	–	Object k, v, r; Map.Entry<?,?> e;
3338	–	return ((o instanceof Map.Entry) &&
3339	–	(k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
3340	–	(r = map.get(k)) != null &&
3341	–	(v = e.getValue()) != null &&
3342	–	(v == r || v.equals(r)));
3343	–	}
3344	–	public final boolean remove(Object o) {
3345	–	Object k, v; Map.Entry<?,?> e;
3346	–	return ((o instanceof Map.Entry) &&
3347	–	(k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
3348	–	(v = e.getValue()) != null &&
3349	–	map.remove(k, v));
3350	–	}
3351	–	public final Iterator<Map.Entry<K,V>> iterator() {
3352	–	return new EntryIterator<K,V>(map);
3353	–	}
3354	–	public final boolean add(Entry<K,V> e) {
3355	–	throw new UnsupportedOperationException();
3356	–	}
3357	–	public final boolean addAll(Collection<? extends Entry<K,V>> c) {
3358	–	throw new UnsupportedOperationException();
3359	–	}
3360	–	public boolean equals(Object o) {
3361	–	Set<?> c;
3362	–	return ((o instanceof Set) &&
3363	–	((c = (Set<?>)o) == this ||
3364	–	(containsAll(c) && c.containsAll(this))));
3365	–	}
3366	–	}
3367	–
3281		/* ---------------- Serialization Support -------------- */
3282
3283		/**
#	Line 3531 | Line 3444 | public class ConcurrentHashMapV8<K, V>
3444		// -------------------------------------------------------
3445
3446		/**
3447	<	* Returns an extended {@link Parallel} view of this map using the
3535	<	* given executor for bulk parallel operations.
3447	>	* Performs the given action for each (key, value).
3448		*
3449	<	* @param executor the executor
3538	<	* @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
3689	<	* function are ignored.
3690	<	*
3691	<	* @param searchFunction a function returning a non-null
3692	<	* result on success, else null
3693	<	* @return a non-null result from applying the given search
3694	<	* function on each (key, value), or null if none
3695	<	*/
3696	<	public <U> U search(BiFun<? super K, ? super V, ? extends U> searchFunction) {
3697	<	return fjp.invoke(ForkJoinTasks.search
3698	<	(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) {
3715	<	return fjp.invoke(ForkJoinTasks.reduce
3716	<	(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
3741	<	* 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
3745	<	* @param basis the identity (initial default value) for the reduction
3746	<	* @param reducer a commutative associative combining function
3747	<	* @return the result of accumulating the given transformation
3748	<	* 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
3763	<	* for an element
3764	<	* @param basis the identity (initial default value) for the reduction
3765	<	* @param reducer a commutative associative combining function
3766	<	* @return the result of accumulating the given transformation
3767	<	* 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 3778 | 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 3792 | 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 3810 | 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 3823 | 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));
3829	<	}
3830	<
3831	<	/**
3832	<	* Returns the result of accumulating the given transformation
3833	<	* of all keys using the given reducer to combine values, or
3834	<	* null if none.
3835	<	*
3836	<	* @param transformer a function returning the transformation
3837	<	* for an element, or null of there is no transformation (in
3838	<	* which case it is not combined).
3839	<	* @param reducer a commutative associative combining function
3840	<	* @return the result of accumulating the given transformation
3841	<	* of all keys
3842	<	*/
3843	<	public <U> U reduceKeys(Fun<? super K, ? extends U> transformer,
3844	<	BiFun<? super U, ? super U, ? extends U> reducer) {
3845	<	return fjp.invoke(ForkJoinTasks.reduceKeys
3846	<	(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 3858 | 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 3877 | 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 3896 | 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 3908 | 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 3921 | 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 3940 | 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 3952 | 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 3969 | 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 3987 | 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 4006 | 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 4025 | 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 4037 | 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 4051 | 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 4069 | 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 4081 | 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 4098 | 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 4116 | 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 4135 | 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 4154 | 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 4187 | 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, null, -1, action);
4668	>	return new ForEachMappingTask<K,V>(map, null, -1, null, action);
4669		}
4670
4671		/**
#	Line 4196 | 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 4208 | 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, null, -1, transformer, action);
4689	>	(map, null, -1, null, transformer, action);
4690		}
4691
4692		/**
#	Line 4228 | 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, null, -1, searchFunction,
4709	>	(map, null, -1, null, searchFunction,
4710		new AtomicReference<U>());
4711		}
4712
#	Line 4239 | 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 4337 | 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, null, -1, action);
4818	>	return new ForEachKeyTask<K,V>(map, null, -1, null, action);
4819		}
4820
4821		/**
#	Line 4346 | 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 4358 | 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, null, -1, transformer, action);
4839	>	(map, null, -1, null, transformer, action);
4840		}
4841
4842		/**
#	Line 4378 | 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, null, -1, searchFunction,
4859	>	(map, null, -1, null, searchFunction,
4860		new AtomicReference<U>());
4861		}
4862
#	Line 4406 | 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 4504 | 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, null, -1, action);
4985	>	return new ForEachValueTask<K,V>(map, null, -1, null, action);
4986		}
4987
4988		/**
#	Line 4513 | 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 4524 | 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, null, -1, transformer, action);
5005	>	(map, null, -1, null, transformer, action);
5006		}
5007
5008		/**
#	Line 4538 | 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
4541	–	*
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, null, -1, searchFunction,
5025	>	(map, null, -1, null, searchFunction,
5026		new AtomicReference<U>());
5027		}
5028
#	Line 4573 | 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 4671 | 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, null, -1, action);
5151	>	return new ForEachEntryTask<K,V>(map, null, -1, null, action);
5152		}
5153
5154		/**
#	Line 4680 | 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 4691 | 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, null, -1, transformer, action);
5171	>	(map, null, -1, null, transformer, action);
5172		}
5173
5174		/**
#	Line 4705 | 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
4708	–	*
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, null, -1, searchFunction,
5191	>	(map, null, -1, null, searchFunction,
5192		new AtomicReference<U>());
5193		}
5194
#	Line 4740 | 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 4864 | Line 5340 | public class ConcurrentHashMapV8<K, V>
5340		}
5341		}
5342
4867	–	// FJ methods
4868	–
4869	–	/**
4870	–	* Propagates completion. Note that all reduce actions
4871	–	* bypass this method to combine while completing.
4872	–	*/
4873	–	final void tryComplete() {
4874	–	BulkTask<K,V,?> a = this, s = a;
4875	–	for (int c;;) {
4876	–	if ((c = a.pending) == 0) {
4877	–	if ((a = (s = a).parent) == null) {
4878	–	s.quietlyComplete();
4879	–	break;
4880	–	}
4881	–	}
4882	–	else if (U.compareAndSwapInt(a, PENDING, c, c - 1))
4883	–	break;
4884	–	}
4885	–	}
4886	–
5343		/**
5344		* Forces root task to complete.
5345		* @param ex if null, complete normally, else exceptionally
#	Line 4925 | Line 5381 | public class ConcurrentHashMapV8<K, V>
5381		* dividing by two anyway.
5382		*/
5383		final int batch() {
5384	<	ConcurrentHashMapV8<K, V> m; int b; Node[] t;
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 sp = getPool().getParallelism() << 3; // slack of 8
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		}
#	Line 4959 | 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 4966 | 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, BulkTask<K,V,?> p, int b,
5476	+	ForEachKeyTask<K,V> nextTask,
5477		Action<K> action) {
5478	<	super(m, 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>(map, 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);
4989	–	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, BulkTask<K,V,?> p, int b,
5508	+	ForEachValueTask<K,V> nextTask,
5509		Action<V> action) {
5510	<	super(m, 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>(map, 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);
5019	–	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, BulkTask<K,V,?> p, int b,
5541	+	ForEachEntryTask<K,V> nextTask,
5542		Action<Entry<K,V>> action) {
5543	<	super(m, 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>(map, 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));
5049	–	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, BulkTask<K,V,?> p, int b,
5574	+	ForEachMappingTask<K,V> nextTask,
5575		BiAction<K,V> action) {
5576	<	super(m, p, b);
5576	>	super(m, p, b, nextTask);
5577		this.action = action;
5578		}
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>(map, 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);
5080	–	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, 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, p, b);
5611	>	super(m, p, b, nextTask);
5612		this.transformer = transformer;
5613		this.action = action;
5614
#	Line 5104 | Line 5619 | public class ConcurrentHashMapV8<K, V>
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	<	(map, 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		}
5119	–	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, 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, p, b);
5652	>	super(m, p, b, nextTask);
5653		this.transformer = transformer;
5654		this.action = action;
5655
#	Line 5143 | Line 5660 | public class ConcurrentHashMapV8<K, V>
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	<	(map, 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		}
5158	–	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, 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, p, b);
5693	>	super(m, p, b, nextTask);
5694		this.transformer = transformer;
5695		this.action = action;
5696
#	Line 5182 | Line 5701 | public class ConcurrentHashMapV8<K, V>
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	<	(map, 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		}
5197	–	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, 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, p, b);
5734	>	super(m, p, b, nextTask);
5735		this.transformer = transformer;
5736		this.action = action;
5737
#	Line 5221 | Line 5742 | public class ConcurrentHashMapV8<K, V>
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	<	(map, 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		}
5236	–	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, 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(m, p, b);
5775	>	super(m, p, b, nextTask);
5776		this.searchFunction = searchFunction; this.result = result;
5777		}
5778		@SuppressWarnings("unchecked") public final boolean exec() {
#	Line 5258 | 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>(map, 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 5273 | Line 5797 | public class ConcurrentHashMapV8<K, V>
5797		break;
5798		}
5799		}
5276	–	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, 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(m, p, b);
5818	>	super(m, p, b, nextTask);
5819		this.searchFunction = searchFunction; this.result = result;
5820		}
5821		@SuppressWarnings("unchecked") public final boolean exec() {
#	Line 5299 | 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>(map, 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 5314 | Line 5840 | public class ConcurrentHashMapV8<K, V>
5840		break;
5841		}
5842		}
5317	–	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, 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(m, p, b);
5861	>	super(m, p, b, nextTask);
5862		this.searchFunction = searchFunction; this.result = result;
5863		}
5864		@SuppressWarnings("unchecked") public final boolean exec() {
#	Line 5340 | 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>(map, 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 5355 | Line 5883 | public class ConcurrentHashMapV8<K, V>
5883		break;
5884		}
5885		}
5358	–	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, 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(m, p, b);
5904	>	super(m, p, b, nextTask);
5905		this.searchFunction = searchFunction; this.result = result;
5906		}
5907		@SuppressWarnings("unchecked") public final boolean exec() {
#	Line 5381 | 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>(map, 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 5396 | Line 5926 | public class ConcurrentHashMapV8<K, V>
5926		break;
5927		}
5928		}
5399	–	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 5454 | 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 5509 | 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 5564 | 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 5623 | 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 5683 | 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 5743 | 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 5803 | 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 5861 | 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 5920 | 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 5979 | 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 6038 | 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 6096 | 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 6155 | 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 6214 | 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 6273 | 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 6331 | 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 6390 | 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 6449 | 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 6508 | 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
6516	–
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