From a3ddd083ca0672a8c0514a8cc6823a7e199eb00f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E8=8B=B1=E6=9D=B0?= <327782001@qq.com> Date: Mon, 3 Apr 2023 17:06:41 +0800 Subject: [PATCH] =?UTF-8?q?fix:map=E6=BA=90=E7=A0=81=E5=AD=A6=E4=B9=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- util/HashMap.java | 11 +- util/concurrent/ConcurrentHashMap.java | 3304 +++++++++++++----------- 2 files changed, 1807 insertions(+), 1508 deletions(-) diff --git a/util/HashMap.java b/util/HashMap.java index 47935cd..bf6ac14 100644 --- a/util/HashMap.java +++ b/util/HashMap.java @@ -747,9 +747,14 @@ public class HashMap extends AbstractMap //在新的Node数组中，将该红黑树进行拆分 //如果拆分后的子树过小(子树的节点小于等于6个)，则取消树化，即将其转为链表结构 ((TreeNode) e).split(this, newTab, j, oldCap); - } else {//如果是链表的情况下，则进行下面的链表数据转移的操作 - Node loHead = null, loTail = null;//低头尾 - Node hiHead = null, hiTail = null;//高头尾 + } else { + //新的位置只有两种可能：原位置，原位置+老数组长度 + //把原链表拆成两个链表，然后再分别插入到新数组的两个位置上 + //不用多次调用put方法 + //如果是链表的情况下，则进行下面的链表数据转移的操作 + //分别是原位置不变的链表和原位置+原数组长度位置的链表 + Node loHead = null, loTail = null; + Node hiHead = null, hiTail = null; Node next; do { //对链表进行遍历，把链表中的节点分成两个类别，一类是需要更换数组下标的，另一类是不需要的 diff --git a/util/concurrent/ConcurrentHashMap.java b/util/concurrent/ConcurrentHashMap.java index 880ecb2..5116ffa 100644 --- a/util/concurrent/ConcurrentHashMap.java +++ b/util/concurrent/ConcurrentHashMap.java @@ -259,13 +259,21 @@ import java.util.stream.Stream; * * Java Collections Framework. * - * @since 1.5 - * @author Doug Lea * @param the type of keys maintained by this map * @param the type of mapped values + * @author Doug Lea + * @since 1.5 + */ + +/** + * 在jdk1.7中是采用Segment + HashEntry + ReentrantLock的方式进行实现的， + * 而1.8中放弃了Segment臃肿的设计，取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现。 + * + * @param + * @param */ -public class ConcurrentHashMap extends AbstractMap - implements ConcurrentMap, Serializable { +public class ConcurrentHashMap extends AbstractMap + implements ConcurrentMap, Serializable { private static final long serialVersionUID = 7249069246763182397L; /* @@ -591,56 +599,78 @@ public class ConcurrentHashMap extends AbstractMap /* * Encodings for Node hash fields. See above for explanation. */ - static final int MOVED = -1; // hash for forwarding nodes - static final int TREEBIN = -2; // hash for roots of trees - static final int RESERVED = -3; // hash for transient reservations + static final int MOVED = -1; // hash for forwarding nodes + static final int TREEBIN = -2; // hash for roots of trees + static final int RESERVED = -3; // hash for transient reservations static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash - /** Number of CPUS, to place bounds on some sizings */ + /** + * Number of CPUS, to place bounds on some sizings + */ static final int NCPU = Runtime.getRuntime().availableProcessors(); - /** For serialization compatibility. */ + /** + * For serialization compatibility. + */ private static final ObjectStreamField[] serialPersistentFields = { - new ObjectStreamField("segments", Segment[].class), - new ObjectStreamField("segmentMask", Integer.TYPE), - new ObjectStreamField("segmentShift", Integer.TYPE) + new ObjectStreamField("segments", Segment[].class), + new ObjectStreamField("segmentMask", Integer.TYPE), + new ObjectStreamField("segmentShift", Integer.TYPE) }; + private Object key; /* ---------------- Nodes -------------- */ /** - * Key-value entry. This class is never exported out as a - * user-mutable Map.Entry (i.e., one supporting setValue; see - * MapEntry below), but can be used for read-only traversals used - * in bulk tasks. Subclasses of Node with a negative hash field - * are special, and contain null keys and values (but are never - * exported). Otherwise, keys and vals are never null. + * 使用volatile修饰,是读操作不加锁的关键 + * + * @param + * @param */ - static class Node implements Map.Entry { + static class Node implements Map.Entry { final int hash; final K key; - volatile V val; - volatile Node next; + volatile V val;//值 + volatile Node next;//下一个Node - Node(int hash, K key, V val, Node next) { + Node(int hash, K key, V val, Node next) { this.hash = hash; this.key = key; this.val = val; this.next = next; } - public final K getKey() { return key; } - public final V getValue() { return val; } - public final int hashCode() { return key.hashCode() ^ val.hashCode(); } - public final String toString(){ return key + "=" + val; } + @Override + public final K getKey() { + return key; + } + + @Override + public final V getValue() { + return val; + } + + @Override + public final int hashCode() { + return key.hashCode() ^ val.hashCode(); + } + + @Override + public final String toString() { + return key + "=" + val; + } + + @Override public final V setValue(V value) { throw new UnsupportedOperationException(); } + @Override public final boolean equals(Object o) { - Object k, v, u; Map.Entry e; + Object k, v, u; + Map.Entry e; return ((o instanceof Map.Entry) && - (k = (e = (Map.Entry)o).getKey()) != null && + (k = (e = (Map.Entry) o).getKey()) != null && (v = e.getValue()) != null && (k == key || k.equals(key)) && (v == (u = val) || v.equals(u))); @@ -649,13 +679,13 @@ public class ConcurrentHashMap extends AbstractMap /** * Virtualized support for map.get(); overridden in subclasses. */ - Node find(int h, Object k) { - Node e = this; + Node find(int h, Object k) { + Node e = this; if (k != null) { do { K ek; if (e.hash == h && - ((ek = e.key) == k || (ek != null && k.equals(ek)))) + ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; } while ((e = e.next) != null); } @@ -705,16 +735,19 @@ public class ConcurrentHashMap extends AbstractMap */ static Class comparableClassFor(Object x) { if (x instanceof Comparable) { - Class c; Type[] ts, as; Type t; ParameterizedType p; + Class c; + Type[] ts, as; + Type t; + ParameterizedType p; if ((c = x.getClass()) == String.class) // bypass checks return c; if ((ts = c.getGenericInterfaces()) != null) { for (int i = 0; i < ts.length; ++i) { if (((t = ts[i]) instanceof ParameterizedType) && - ((p = (ParameterizedType)t).getRawType() == - Comparable.class) && - (as = p.getActualTypeArguments()) != null && - as.length == 1 && as[0] == c) // type arg is c + ((p = (ParameterizedType) t).getRawType() == + Comparable.class) && + (as = p.getActualTypeArguments()) != null && + as.length == 1 && as[0] == c) // type arg is c return c; } } @@ -726,10 +759,10 @@ public class ConcurrentHashMap extends AbstractMap * Returns k.compareTo(x) if x matches kc (k's screened comparable * class), else 0. */ - @SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable + @SuppressWarnings({"rawtypes", "unchecked"}) // for cast to Comparable static int compareComparables(Class kc, Object k, Object x) { return (x == null || x.getClass() != kc ? 0 : - ((Comparable)k).compareTo(x)); + ((Comparable) k).compareTo(x)); } /* ---------------- Table element access -------------- */ @@ -751,31 +784,30 @@ public class ConcurrentHashMap extends AbstractMap */ @SuppressWarnings("unchecked") - static final Node tabAt(Node[] tab, int i) { - return (Node)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE); + static final Node tabAt(Node[] tab, int i) { + return (Node) U.getObjectVolatile(tab, ((long) i << ASHIFT) + ABASE); } - static final boolean casTabAt(Node[] tab, int i, - Node c, Node v) { - return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v); + static final boolean casTabAt(Node[] tab, int i, + Node c, Node v) { + return U.compareAndSwapObject(tab, ((long) i << ASHIFT) + ABASE, c, v); } - static final void setTabAt(Node[] tab, int i, Node v) { - U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v); + static final void setTabAt(Node[] tab, int i, Node v) { + U.putObjectVolatile(tab, ((long) i << ASHIFT) + ABASE, v); } /* ---------------- Fields -------------- */ /** - * The array of bins. Lazily initialized upon first insertion. - * Size is always a power of two. Accessed directly by iterators. + * 数组用volatile修饰主要是保证在数组扩容的时候保证可见性 */ - transient volatile Node[] table; + transient volatile Node[] table; /** * The next table to use; non-null only while resizing. */ - private transient volatile Node[] nextTable; + private transient volatile Node[] nextTable; /** * Base counter value, used mainly when there is no contention, @@ -810,9 +842,9 @@ public class ConcurrentHashMap extends AbstractMap private transient volatile CounterCell[] counterCells; // views - private transient KeySetView keySet; - private transient ValuesView values; - private transient EntrySetView entrySet; + private transient KeySetView keySet; + private transient ValuesView values; + private transient EntrySetView entrySet; /* ---------------- Public operations -------------- */ @@ -829,16 +861,16 @@ public class ConcurrentHashMap extends AbstractMap * to dynamically resize. * * @param initialCapacity The implementation performs internal - * sizing to accommodate this many elements. + * sizing to accommodate this many elements. * @throws IllegalArgumentException if the initial capacity of - * elements is negative + * elements is negative */ public ConcurrentHashMap(int initialCapacity) { if (initialCapacity < 0) throw new IllegalArgumentException(); int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ? - MAXIMUM_CAPACITY : - tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1)); + MAXIMUM_CAPACITY : + tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1)); this.sizeCtl = cap; } @@ -858,13 +890,12 @@ public class ConcurrentHashMap extends AbstractMap * initial table density ({@code loadFactor}). * * @param initialCapacity the initial capacity. The implementation - * performs internal sizing to accommodate this many elements, - * given the specified load factor. - * @param loadFactor the load factor (table density) for - * establishing the initial table size + * performs internal sizing to accommodate this many elements, + * given the specified load factor. + * @param loadFactor the load factor (table density) for + * establishing the initial table size * @throws IllegalArgumentException if the initial capacity of - * elements is negative or the load factor is nonpositive - * + * elements is negative or the load factor is nonpositive * @since 1.6 */ public ConcurrentHashMap(int initialCapacity, float loadFactor) { @@ -877,17 +908,17 @@ public class ConcurrentHashMap extends AbstractMap * density ({@code loadFactor}), and number of concurrently * updating threads ({@code concurrencyLevel}). * - * @param initialCapacity the initial capacity. The implementation - * performs internal sizing to accommodate this many elements, - * given the specified load factor. - * @param loadFactor the load factor (table density) for - * establishing the initial table size + * @param initialCapacity the initial capacity. The implementation + * performs internal sizing to accommodate this many elements, + * given the specified load factor. + * @param loadFactor the load factor (table density) for + * establishing the initial table size * @param concurrencyLevel the estimated number of concurrently - * updating threads. The implementation may use this value as - * a sizing hint. + * updating threads. The implementation may use this value as + * a sizing hint. * @throws IllegalArgumentException if the initial capacity is - * negative or the load factor or concurrencyLevel are - * nonpositive + * negative or the load factor or concurrencyLevel are + * nonpositive */ public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) { @@ -895,9 +926,9 @@ public class ConcurrentHashMap extends AbstractMap throw new IllegalArgumentException(); if (initialCapacity < concurrencyLevel) // Use at least as many bins initialCapacity = concurrencyLevel; // as estimated threads - long size = (long)(1.0 + (long)initialCapacity / loadFactor); - int cap = (size >= (long)MAXIMUM_CAPACITY) ? - MAXIMUM_CAPACITY : tableSizeFor((int)size); + long size = (long) (1.0 + (long) initialCapacity / loadFactor); + int cap = (size >= (long) MAXIMUM_CAPACITY) ? + MAXIMUM_CAPACITY : tableSizeFor((int) size); this.sizeCtl = cap; } @@ -906,16 +937,18 @@ public class ConcurrentHashMap extends AbstractMap /** * {@inheritDoc} */ + @Override public int size() { long n = sumCount(); return ((n < 0L) ? 0 : - (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE : - (int)n); + (n > (long) Integer.MAX_VALUE) ? Integer.MAX_VALUE : + (int) n); } /** * {@inheritDoc} */ + @Override public boolean isEmpty() { return sumCount() <= 0L; // ignore transient negative values } @@ -931,21 +964,35 @@ public class ConcurrentHashMap extends AbstractMap * * @throws NullPointerException if the specified key is null */ + @Override public V get(Object key) { - Node[] tab; Node e, p; int n, eh; K ek; - int h = spread(key.hashCode()); + this.key = key; + //读操作不需要加锁 + Node[] tab; + Node e, p; + int n, eh; + K ek; + int h = spread(key.hashCode());//计算hash if ((tab = table) != null && (n = tab.length) > 0 && - (e = tabAt(tab, (n - 1) & h)) != null) { - if ((eh = e.hash) == h) { - if ((ek = e.key) == key || (ek != null && key.equals(ek))) + (e = tabAt(tab, (n - 1) & h)) != null) {//读取首节点的Node元素 + if ((eh = e.hash) == h) {//如果该节点就是首节点就返回 + if ((ek = e.key) == key || (ek != null && key.equals(ek))) { return e.val; + } } - else if (eh < 0) + //hash值为负值表示正在扩容，这个时候查的是ForwardingNode的find方法来定位到nextTable来 + //eh=-1，说明该节点是一个ForwardingNode，正在迁移，此时调用ForwardingNode的find方法去nextTable里找。 + //eh=-2，说明该节点是一个TreeBin，此时调用TreeBin的find方法遍历红黑树，由于红黑树有可能正在旋转变色，所以find里会有读写锁。 + //eh>=0，说明该节点下挂的是一个链表，直接遍历该链表即可。 + else if (eh < 0) { return (p = e.find(h, key)) != null ? p.val : null; + } + //既不是首节点也不是ForwardingNode，那就往下遍历 while ((e = e.next) != null) { if (e.hash == h && - ((ek = e.key) == key || (ek != null && key.equals(ek)))) + ((ek = e.key) == key || (ek != null && key.equals(ek)))) { return e.val; + } } } return null; @@ -954,12 +1001,13 @@ public class ConcurrentHashMap extends AbstractMap /** * Tests if the specified object is a key in this table. * - * @param key possible key + * @param key possible key * @return {@code true} if and only if the specified object - * is a key in this table, as determined by the - * {@code equals} method; {@code false} otherwise + * is a key in this table, as determined by the + * {@code equals} method; {@code false} otherwise * @throws NullPointerException if the specified key is null */ + @Override public boolean containsKey(Object key) { return get(key) != null; } @@ -971,16 +1019,17 @@ public class ConcurrentHashMap extends AbstractMap * * @param value value whose presence in this map is to be tested * @return {@code true} if this map maps one or more keys to the - * specified value + * specified value * @throws NullPointerException if the specified value is null */ + @Override public boolean containsValue(Object value) { if (value == null) throw new NullPointerException(); - Node[] t; + Node[] t; if ((t = table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) { + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) { V v; if ((v = p.val) == value || (v != null && value.equals(v))) return true; @@ -996,61 +1045,63 @@ public class ConcurrentHashMap extends AbstractMap *

The value can be retrieved by calling the {@code get} method * with a key that is equal to the original key. * - * @param key key with which the specified value is to be associated + * @param key key with which the specified value is to be associated * @param value value to be associated with the specified key * @return the previous value associated with {@code key}, or - * {@code null} if there was no mapping for {@code key} + * {@code null} if there was no mapping for {@code key} * @throws NullPointerException if the specified key or value is null */ + @Override public V put(K key, V value) { return putVal(key, value, false); } - /** Implementation for put and putIfAbsent */ + /** + * Implementation for put and putIfAbsent + */ final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerException(); int hash = spread(key.hashCode()); int binCount = 0; - for (Node[] tab = table;;) { - Node f; int n, i, fh; + for (Node[] tab = table; ; ) { + Node f; + int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { if (casTabAt(tab, i, null, - new Node(hash, key, value, null))) + new Node(hash, key, value, null))) break; // no lock when adding to empty bin - } - else if ((fh = f.hash) == MOVED) + } else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); else { V oldVal = null; - synchronized (f) { + synchronized (f) {//写操作加锁 if (tabAt(tab, i) == f) { if (fh >= 0) { binCount = 1; - for (Node e = f;; ++binCount) { + for (Node e = f; ; ++binCount) { K ek; if (e.hash == hash && - ((ek = e.key) == key || - (ek != null && key.equals(ek)))) { + ((ek = e.key) == key || + (ek != null && key.equals(ek)))) { oldVal = e.val; if (!onlyIfAbsent) e.val = value; break; } - Node pred = e; + Node pred = e; if ((e = e.next) == null) { - pred.next = new Node(hash, key, - value, null); + pred.next = new Node(hash, key, + value, null); break; } } - } - else if (f instanceof TreeBin) { - Node p; + } else if (f instanceof TreeBin) { + Node p; binCount = 2; - if ((p = ((TreeBin)f).putTreeVal(hash, key, - value)) != null) { + if ((p = ((TreeBin) f).putTreeVal(hash, key, + value)) != null) { oldVal = p.val; if (!onlyIfAbsent) p.val = value; @@ -1088,9 +1139,9 @@ public class ConcurrentHashMap extends AbstractMap * Removes the key (and its corresponding value) from this map. * This method does nothing if the key is not in the map. * - * @param key the key that needs to be removed + * @param key the key that needs to be removed * @return the previous value associated with {@code key}, or - * {@code null} if there was no mapping for {@code key} + * {@code null} if there was no mapping for {@code key} * @throws NullPointerException if the specified key is null */ public V remove(Object key) { @@ -1104,10 +1155,11 @@ public class ConcurrentHashMap extends AbstractMap */ final V replaceNode(Object key, V value, Object cv) { int hash = spread(key.hashCode()); - for (Node[] tab = table;;) { - Node f; int n, i, fh; + for (Node[] tab = table; ; ) { + Node f; + int n, i, fh; if (tab == null || (n = tab.length) == 0 || - (f = tabAt(tab, i = (n - 1) & hash)) == null) + (f = tabAt(tab, i = (n - 1) & hash)) == null) break; else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); @@ -1118,14 +1170,14 @@ public class ConcurrentHashMap extends AbstractMap if (tabAt(tab, i) == f) { if (fh >= 0) { validated = true; - for (Node e = f, pred = null;;) { + for (Node e = f, pred = null; ; ) { K ek; if (e.hash == hash && - ((ek = e.key) == key || - (ek != null && key.equals(ek)))) { + ((ek = e.key) == key || + (ek != null && key.equals(ek)))) { V ev = e.val; if (cv == null || cv == ev || - (ev != null && cv.equals(ev))) { + (ev != null && cv.equals(ev))) { oldVal = ev; if (value != null) e.val = value; @@ -1140,16 +1192,15 @@ public class ConcurrentHashMap extends AbstractMap if ((e = e.next) == null) break; } - } - else if (f instanceof TreeBin) { + } else if (f instanceof TreeBin) { validated = true; - TreeBin t = (TreeBin)f; - TreeNode r, p; + TreeBin t = (TreeBin) f; + TreeNode r, p; if ((r = t.root) != null && - (p = r.findTreeNode(hash, key, null)) != null) { + (p = r.findTreeNode(hash, key, null)) != null) { V pv = p.val; if (cv == null || cv == pv || - (pv != null && cv.equals(pv))) { + (pv != null && cv.equals(pv))) { oldVal = pv; if (value != null) p.val = value; @@ -1179,22 +1230,21 @@ public class ConcurrentHashMap extends AbstractMap public void clear() { long delta = 0L; // negative number of deletions int i = 0; - Node[] tab = table; + Node[] tab = table; while (tab != null && i < tab.length) { int fh; - Node f = tabAt(tab, i); + Node f = tabAt(tab, i); if (f == null) ++i; else if ((fh = f.hash) == MOVED) { tab = helpTransfer(tab, f); i = 0; // restart - } - else { + } else { synchronized (f) { if (tabAt(tab, i) == f) { - Node p = (fh >= 0 ? f : - (f instanceof TreeBin) ? - ((TreeBin)f).first : null); + Node p = (fh >= 0 ? f : + (f instanceof TreeBin) ? + ((TreeBin) f).first : null); while (p != null) { --delta; p = p.next; @@ -1226,9 +1276,9 @@ public class ConcurrentHashMap extends AbstractMap * * @return the set view */ - public KeySetView keySet() { - KeySetView ks; - return (ks = keySet) != null ? ks : (keySet = new KeySetView(this, null)); + public KeySetView keySet() { + KeySetView ks; + return (ks = keySet) != null ? ks : (keySet = new KeySetView(this, null)); } /** @@ -1249,9 +1299,10 @@ public class ConcurrentHashMap extends AbstractMap * * @return the collection view */ + @Override public Collection values() { - ValuesView vs; - return (vs = values) != null ? vs : (values = new ValuesView(this)); + ValuesView vs; + return (vs = values) != null ? vs : (values = new ValuesView(this)); } /** @@ -1271,9 +1322,10 @@ public class ConcurrentHashMap extends AbstractMap * * @return the set view */ - public Set> entrySet() { - EntrySetView es; - return (es = entrySet) != null ? es : (entrySet = new EntrySetView(this)); + @Override + public Set> entrySet() { + EntrySetView es; + return (es = entrySet) != null ? es : (entrySet = new EntrySetView(this)); } /** @@ -1285,10 +1337,10 @@ public class ConcurrentHashMap extends AbstractMap */ public int hashCode() { int h = 0; - Node[] t; + Node[] t; if ((t = table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) h += p.key.hashCode() ^ p.val.hashCode(); } return h; @@ -1306,14 +1358,14 @@ public class ConcurrentHashMap extends AbstractMap * @return a string representation of this map */ public String toString() { - Node[] t; + Node[] t; int f = (t = table) == null ? 0 : t.length; - Traverser it = new Traverser(t, f, 0, f); + Traverser it = new Traverser(t, f, 0, f); StringBuilder sb = new StringBuilder(); sb.append('{'); - Node p; + Node p; if ((p = it.advance()) != null) { - for (;;) { + for (; ; ) { K k = p.key; V v = p.val; sb.append(k == this ? "(this Map)" : k); @@ -1341,22 +1393,22 @@ public class ConcurrentHashMap extends AbstractMap if (o != this) { if (!(o instanceof Map)) return false; - Map m = (Map) o; - Node[] t; + Map m = (Map) o; + Node[] t; int f = (t = table) == null ? 0 : t.length; - Traverser it = new Traverser(t, f, 0, f); - for (Node p; (p = it.advance()) != null; ) { + Traverser it = new Traverser(t, f, 0, f); + for (Node p; (p = it.advance()) != null; ) { V val = p.val; Object v = m.get(p.key); if (v == null || (v != val && !v.equals(val))) return false; } - for (Map.Entry e : m.entrySet()) { + for (Map.Entry e : m.entrySet()) { Object mk, mv, v; if ((mk = e.getKey()) == null || - (mv = e.getValue()) == null || - (v = get(mk)) == null || - (mv != v && !mv.equals(v))) + (mv = e.getValue()) == null || + (v = get(mk)) == null || + (mv != v && !mv.equals(v))) return false; } } @@ -1367,24 +1419,27 @@ public class ConcurrentHashMap extends AbstractMap * Stripped-down version of helper class used in previous version, * declared for the sake of serialization compatibility */ - static class Segment extends ReentrantLock implements Serializable { + static class Segment extends ReentrantLock implements Serializable { private static final long serialVersionUID = 2249069246763182397L; final float loadFactor; - Segment(float lf) { this.loadFactor = lf; } + + Segment(float lf) { + this.loadFactor = lf; + } } /** * Saves the state of the {@code ConcurrentHashMap} instance to a * stream (i.e., serializes it). + * * @param s the stream * @throws java.io.IOException if an I/O error occurs - * @serialData - * the key (Object) and value (Object) + * @serialData the key (Object) and value (Object) * for each key-value mapping, followed by a null pair. * The key-value mappings are emitted in no particular order. */ private void writeObject(java.io.ObjectOutputStream s) - throws java.io.IOException { + throws java.io.IOException { // For serialization compatibility // Emulate segment calculation from previous version of this class int sshift = 0; @@ -1396,19 +1451,19 @@ public class ConcurrentHashMap extends AbstractMap int segmentShift = 32 - sshift; int segmentMask = ssize - 1; @SuppressWarnings("unchecked") - Segment[] segments = (Segment[]) - new Segment[DEFAULT_CONCURRENCY_LEVEL]; + Segment[] segments = (Segment[]) + new Segment[DEFAULT_CONCURRENCY_LEVEL]; for (int i = 0; i < segments.length; ++i) - segments[i] = new Segment(LOAD_FACTOR); + segments[i] = new Segment(LOAD_FACTOR); s.putFields().put("segments", segments); s.putFields().put("segmentShift", segmentShift); s.putFields().put("segmentMask", segmentMask); s.writeFields(); - Node[] t; + Node[] t; if ((t = table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) { + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) { s.writeObject(p.key); s.writeObject(p.val); } @@ -1420,13 +1475,14 @@ public class ConcurrentHashMap extends AbstractMap /** * Reconstitutes the instance from a stream (that is, deserializes it). + * * @param s the stream * @throws ClassNotFoundException if the class of a serialized object - * could not be found - * @throws java.io.IOException if an I/O error occurs + * could not be found + * @throws java.io.IOException if an I/O error occurs */ private void readObject(java.io.ObjectInputStream s) - throws java.io.IOException, ClassNotFoundException { + throws java.io.IOException, ClassNotFoundException { /* * To improve performance in typical cases, we create nodes * while reading, then place in table once size is known. @@ -1437,55 +1493,54 @@ public class ConcurrentHashMap extends AbstractMap sizeCtl = -1; // force exclusion for table construction s.defaultReadObject(); long size = 0L; - Node p = null; - for (;;) { + Node p = null; + for (; ; ) { @SuppressWarnings("unchecked") K k = (K) s.readObject(); @SuppressWarnings("unchecked") V v = (V) s.readObject(); if (k != null && v != null) { - p = new Node(spread(k.hashCode()), k, v, p); + p = new Node(spread(k.hashCode()), k, v, p); ++size; - } - else + } else break; } if (size == 0L) sizeCtl = 0; else { int n; - if (size >= (long)(MAXIMUM_CAPACITY >>> 1)) + if (size >= (long) (MAXIMUM_CAPACITY >>> 1)) n = MAXIMUM_CAPACITY; else { - int sz = (int)size; + int sz = (int) size; n = tableSizeFor(sz + (sz >>> 1) + 1); } @SuppressWarnings("unchecked") - Node[] tab = (Node[])new Node[n]; + Node[] tab = (Node[]) new Node[n]; int mask = n - 1; long added = 0L; while (p != null) { boolean insertAtFront; - Node next = p.next, first; + Node next = p.next, first; int h = p.hash, j = h & mask; if ((first = tabAt(tab, j)) == null) insertAtFront = true; else { K k = p.key; if (first.hash < 0) { - TreeBin t = (TreeBin)first; + TreeBin t = (TreeBin) first; if (t.putTreeVal(h, k, p.val) == null) ++added; insertAtFront = false; - } - else { + } else { int binCount = 0; insertAtFront = true; - Node q; K qk; + Node q; + K qk; for (q = first; q != null; q = q.next) { if (q.hash == h && - ((qk = q.key) == k || - (qk != null && k.equals(qk)))) { + ((qk = q.key) == k || + (qk != null && k.equals(qk)))) { insertAtFront = false; break; } @@ -1495,17 +1550,17 @@ public class ConcurrentHashMap extends AbstractMap insertAtFront = false; ++added; p.next = first; - TreeNode hd = null, tl = null; + TreeNode hd = null, tl = null; for (q = p; q != null; q = q.next) { - TreeNode t = new TreeNode - (q.hash, q.key, q.val, null, null); + TreeNode t = new TreeNode + (q.hash, q.key, q.val, null, null); if ((t.prev = tl) == null) hd = t; else tl.next = t; tl = t; } - setTabAt(tab, j, new TreeBin(hd)); + setTabAt(tab, j, new TreeBin(hd)); } } } @@ -1528,7 +1583,7 @@ public class ConcurrentHashMap extends AbstractMap * {@inheritDoc} * * @return the previous value associated with the specified key, - * or {@code null} if there was no mapping for the key + * or {@code null} if there was no mapping for the key * @throws NullPointerException if the specified key or value is null */ public V putIfAbsent(K key, V value) { @@ -1561,7 +1616,7 @@ public class ConcurrentHashMap extends AbstractMap * {@inheritDoc} * * @return the previous value associated with the specified key, - * or {@code null} if there was no mapping for the key + * or {@code null} if there was no mapping for the key * @throws NullPointerException if the specified key or value is null */ public V replace(K key, V value) { @@ -1577,9 +1632,9 @@ public class ConcurrentHashMap extends AbstractMap * given default value if this map contains no mapping for the * key. * - * @param key the key whose associated value is to be returned + * @param key the key whose associated value is to be returned * @param defaultValue the value to return if this map contains - * no mapping for the given key + * no mapping for the given key * @return the mapping for the key, if present; else the default value * @throws NullPointerException if the specified key is null */ @@ -1590,10 +1645,10 @@ public class ConcurrentHashMap extends AbstractMap public void forEach(BiConsumer action) { if (action == null) throw new NullPointerException(); - Node[] t; + Node[] t; if ((t = table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) { + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) { action.accept(p.key, p.val); } } @@ -1601,17 +1656,17 @@ public class ConcurrentHashMap extends AbstractMap public void replaceAll(BiFunction function) { if (function == null) throw new NullPointerException(); - Node[] t; + Node[] t; if ((t = table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) { + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) { V oldValue = p.val; - for (K key = p.key;;) { + for (K key = p.key; ; ) { V newValue = function.apply(key, oldValue); if (newValue == null) throw new NullPointerException(); if (replaceNode(key, newValue, oldValue) != null || - (oldValue = get(key)) == null) + (oldValue = get(key)) == null) break; } } @@ -1628,17 +1683,17 @@ public class ConcurrentHashMap extends AbstractMap * is in progress, so the computation should be short and simple, * and must not attempt to update any other mappings of this map. * - * @param key key with which the specified value is to be associated + * @param key key with which the specified value is to be associated * @param mappingFunction the function to compute a value * @return the current (existing or computed) value associated with - * the specified key, or null if the computed value is null - * @throws NullPointerException if the specified key or mappingFunction - * is null + * the specified key, or null if the computed value is null + * @throws NullPointerException if the specified key or mappingFunction + * is null * @throws IllegalStateException if the computation detectably - * attempts a recursive update to this map that would - * otherwise never complete - * @throws RuntimeException or Error if the mappingFunction does so, - * in which case the mapping is left unestablished + * attempts a recursive update to this map that would + * otherwise never complete + * @throws RuntimeException or Error if the mappingFunction does so, + * in which case the mapping is left unestablished */ public V computeIfAbsent(K key, Function mappingFunction) { if (key == null || mappingFunction == null) @@ -1646,19 +1701,20 @@ public class ConcurrentHashMap extends AbstractMap int h = spread(key.hashCode()); V val = null; int binCount = 0; - for (Node[] tab = table;;) { - Node f; int n, i, fh; + for (Node[] tab = table; ; ) { + Node f; + int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & h)) == null) { - Node r = new ReservationNode(); + Node r = new ReservationNode(); synchronized (r) { if (casTabAt(tab, i, null, r)) { binCount = 1; - Node node = null; + Node node = null; try { if ((val = mappingFunction.apply(key)) != null) - node = new Node(h, key, val, null); + node = new Node(h, key, val, null); } finally { setTabAt(tab, i, node); } @@ -1666,8 +1722,7 @@ public class ConcurrentHashMap extends AbstractMap } if (binCount != 0) break; - } - else if ((fh = f.hash) == MOVED) + } else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); else { boolean added = false; @@ -1675,30 +1730,30 @@ public class ConcurrentHashMap extends AbstractMap if (tabAt(tab, i) == f) { if (fh >= 0) { binCount = 1; - for (Node e = f;; ++binCount) { - K ek; V ev; + for (Node e = f; ; ++binCount) { + K ek; + V ev; if (e.hash == h && - ((ek = e.key) == key || - (ek != null && key.equals(ek)))) { + ((ek = e.key) == key || + (ek != null && key.equals(ek)))) { val = e.val; break; } - Node pred = e; + Node pred = e; if ((e = e.next) == null) { if ((val = mappingFunction.apply(key)) != null) { added = true; - pred.next = new Node(h, key, val, null); + pred.next = new Node(h, key, val, null); } break; } } - } - else if (f instanceof TreeBin) { + } else if (f instanceof TreeBin) { binCount = 2; - TreeBin t = (TreeBin)f; - TreeNode r, p; + TreeBin t = (TreeBin) f; + TreeNode r, p; if ((r = t.root) != null && - (p = r.findTreeNode(h, key, null)) != null) + (p = r.findTreeNode(h, key, null)) != null) val = p.val; else if ((val = mappingFunction.apply(key)) != null) { added = true; @@ -1730,16 +1785,16 @@ public class ConcurrentHashMap extends AbstractMap * computation should be short and simple, and must not attempt to * update any other mappings of this map. * - * @param key key with which a value may be associated + * @param key key with which a value may be associated * @param remappingFunction the function to compute a value * @return the new value associated with the specified key, or null if none - * @throws NullPointerException if the specified key or remappingFunction - * is null + * @throws NullPointerException if the specified key or remappingFunction + * is null * @throws IllegalStateException if the computation detectably - * attempts a recursive update to this map that would - * otherwise never complete - * @throws RuntimeException or Error if the remappingFunction does so, - * in which case the mapping is unchanged + * attempts a recursive update to this map that would + * otherwise never complete + * @throws RuntimeException or Error if the remappingFunction does so, + * in which case the mapping is unchanged */ public V computeIfPresent(K key, BiFunction remappingFunction) { if (key == null || remappingFunction == null) @@ -1748,8 +1803,9 @@ public class ConcurrentHashMap extends AbstractMap V val = null; int delta = 0; int binCount = 0; - for (Node[] tab = table;;) { - Node f; int n, i, fh; + for (Node[] tab = table; ; ) { + Node f; + int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & h)) == null) @@ -1761,17 +1817,17 @@ public class ConcurrentHashMap extends AbstractMap if (tabAt(tab, i) == f) { if (fh >= 0) { binCount = 1; - for (Node e = f, pred = null;; ++binCount) { + for (Node e = f, pred = null; ; ++binCount) { K ek; if (e.hash == h && - ((ek = e.key) == key || - (ek != null && key.equals(ek)))) { + ((ek = e.key) == key || + (ek != null && key.equals(ek)))) { val = remappingFunction.apply(key, e.val); if (val != null) e.val = val; else { delta = -1; - Node en = e.next; + Node en = e.next; if (pred != null) pred.next = en; else @@ -1783,13 +1839,12 @@ public class ConcurrentHashMap extends AbstractMap if ((e = e.next) == null) break; } - } - else if (f instanceof TreeBin) { + } else if (f instanceof TreeBin) { binCount = 2; - TreeBin t = (TreeBin)f; - TreeNode r, p; + TreeBin t = (TreeBin) f; + TreeNode r, p; if ((r = t.root) != null && - (p = r.findTreeNode(h, key, null)) != null) { + (p = r.findTreeNode(h, key, null)) != null) { val = remappingFunction.apply(key, p.val); if (val != null) p.val = val; @@ -1807,7 +1862,7 @@ public class ConcurrentHashMap extends AbstractMap } } if (delta != 0) - addCount((long)delta, binCount); + addCount((long) delta, binCount); return val; } @@ -1820,16 +1875,16 @@ public class ConcurrentHashMap extends AbstractMap * computation should be short and simple, and must not attempt to * update any other mappings of this Map. * - * @param key key with which the specified value is to be associated + * @param key key with which the specified value is to be associated * @param remappingFunction the function to compute a value * @return the new value associated with the specified key, or null if none - * @throws NullPointerException if the specified key or remappingFunction - * is null + * @throws NullPointerException if the specified key or remappingFunction + * is null * @throws IllegalStateException if the computation detectably - * attempts a recursive update to this map that would - * otherwise never complete - * @throws RuntimeException or Error if the remappingFunction does so, - * in which case the mapping is unchanged + * attempts a recursive update to this map that would + * otherwise never complete + * @throws RuntimeException or Error if the remappingFunction does so, + * in which case the mapping is unchanged */ public V compute(K key, BiFunction remappingFunction) { @@ -1839,20 +1894,21 @@ public class ConcurrentHashMap extends AbstractMap V val = null; int delta = 0; int binCount = 0; - for (Node[] tab = table;;) { - Node f; int n, i, fh; + for (Node[] tab = table; ; ) { + Node f; + int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & h)) == null) { - Node r = new ReservationNode(); + Node r = new ReservationNode(); synchronized (r) { if (casTabAt(tab, i, null, r)) { binCount = 1; - Node node = null; + Node node = null; try { if ((val = remappingFunction.apply(key, null)) != null) { delta = 1; - node = new Node(h, key, val, null); + node = new Node(h, key, val, null); } } finally { setTabAt(tab, i, node); @@ -1861,25 +1917,24 @@ public class ConcurrentHashMap extends AbstractMap } if (binCount != 0) break; - } - else if ((fh = f.hash) == MOVED) + } else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); else { synchronized (f) { if (tabAt(tab, i) == f) { if (fh >= 0) { binCount = 1; - for (Node e = f, pred = null;; ++binCount) { + for (Node e = f, pred = null; ; ++binCount) { K ek; if (e.hash == h && - ((ek = e.key) == key || - (ek != null && key.equals(ek)))) { + ((ek = e.key) == key || + (ek != null && key.equals(ek)))) { val = remappingFunction.apply(key, e.val); if (val != null) e.val = val; else { delta = -1; - Node en = e.next; + Node en = e.next; if (pred != null) pred.next = en; else @@ -1893,16 +1948,15 @@ public class ConcurrentHashMap extends AbstractMap if (val != null) { delta = 1; pred.next = - new Node(h, key, val, null); + new Node(h, key, val, null); } break; } } - } - else if (f instanceof TreeBin) { + } else if (f instanceof TreeBin) { binCount = 1; - TreeBin t = (TreeBin)f; - TreeNode r, p; + TreeBin t = (TreeBin) f; + TreeNode r, p; if ((r = t.root) != null) p = r.findTreeNode(h, key, null); else @@ -1916,8 +1970,7 @@ public class ConcurrentHashMap extends AbstractMap delta = 1; t.putTreeVal(h, key, val); } - } - else if (p != null) { + } else if (p != null) { delta = -1; if (t.removeTreeNode(p)) setTabAt(tab, i, untreeify(t.first)); @@ -1933,7 +1986,7 @@ public class ConcurrentHashMap extends AbstractMap } } if (delta != 0) - addCount((long)delta, binCount); + addCount((long) delta, binCount); return val; } @@ -1948,14 +2001,14 @@ public class ConcurrentHashMap extends AbstractMap * short and simple, and must not attempt to update any other * mappings of this Map. * - * @param key key with which the specified value is to be associated - * @param value the value to use if absent + * @param key key with which the specified value is to be associated + * @param value the value to use if absent * @param remappingFunction the function to recompute a value if present * @return the new value associated with the specified key, or null if none * @throws NullPointerException if the specified key or the - * remappingFunction is null - * @throws RuntimeException or Error if the remappingFunction does so, - * in which case the mapping is unchanged + * remappingFunction is null + * @throws RuntimeException or Error if the remappingFunction does so, + * in which case the mapping is unchanged */ public V merge(K key, V value, BiFunction remappingFunction) { if (key == null || value == null || remappingFunction == null) @@ -1964,35 +2017,35 @@ public class ConcurrentHashMap extends AbstractMap V val = null; int delta = 0; int binCount = 0; - for (Node[] tab = table;;) { - Node f; int n, i, fh; + for (Node[] tab = table; ; ) { + Node f; + int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & h)) == null) { - if (casTabAt(tab, i, null, new Node(h, key, value, null))) { + if (casTabAt(tab, i, null, new Node(h, key, value, null))) { delta = 1; val = value; break; } - } - else if ((fh = f.hash) == MOVED) + } else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); else { synchronized (f) { if (tabAt(tab, i) == f) { if (fh >= 0) { binCount = 1; - for (Node e = f, pred = null;; ++binCount) { + for (Node e = f, pred = null; ; ++binCount) { K ek; if (e.hash == h && - ((ek = e.key) == key || - (ek != null && key.equals(ek)))) { + ((ek = e.key) == key || + (ek != null && key.equals(ek)))) { val = remappingFunction.apply(e.val, value); if (val != null) e.val = val; else { delta = -1; - Node en = e.next; + Node en = e.next; if (pred != null) pred.next = en; else @@ -2005,19 +2058,18 @@ public class ConcurrentHashMap extends AbstractMap delta = 1; val = value; pred.next = - new Node(h, key, val, null); + new Node(h, key, val, null); break; } } - } - else if (f instanceof TreeBin) { + } else if (f instanceof TreeBin) { binCount = 2; - TreeBin t = (TreeBin)f; - TreeNode r = t.root; - TreeNode p = (r == null) ? null : - r.findTreeNode(h, key, null); + TreeBin t = (TreeBin) f; + TreeNode r = t.root; + TreeNode p = (r == null) ? null : + r.findTreeNode(h, key, null); val = (p == null) ? value : - remappingFunction.apply(p.val, value); + remappingFunction.apply(p.val, value); if (val != null) { if (p != null) p.val = val; @@ -2025,8 +2077,7 @@ public class ConcurrentHashMap extends AbstractMap delta = 1; t.putTreeVal(h, key, val); } - } - else if (p != null) { + } else if (p != null) { delta = -1; if (t.removeTreeNode(p)) setTabAt(tab, i, untreeify(t.first)); @@ -2042,7 +2093,7 @@ public class ConcurrentHashMap extends AbstractMap } } if (delta != 0) - addCount((long)delta, binCount); + addCount((long) delta, binCount); return val; } @@ -2056,11 +2107,11 @@ public class ConcurrentHashMap extends AbstractMap * which supported this method prior to introduction of the * Java Collections framework. * - * @param value a value to search for + * @param value a value to search for * @return {@code true} if and only if some key maps to the - * {@code value} argument in this table as - * determined by the {@code equals} method; - * {@code false} otherwise + * {@code value} argument in this table as + * determined by the {@code equals} method; + * {@code false} otherwise * @throws NullPointerException if the specified value is null */ public boolean contains(Object value) { @@ -2074,9 +2125,9 @@ public class ConcurrentHashMap extends AbstractMap * @see #keySet() */ public Enumeration keys() { - Node[] t; + Node[] t; int f = (t = table) == null ? 0 : t.length; - return new KeyIterator(t, f, 0, f, this); + return new KeyIterator(t, f, 0, f, this); } /** @@ -2086,9 +2137,9 @@ public class ConcurrentHashMap extends AbstractMap * @see #values() */ public Enumeration elements() { - Node[] t; + Node[] t; int f = (t = table) == null ? 0 : t.length; - return new ValueIterator(t, f, 0, f, this); + return new ValueIterator(t, f, 0, f, this); } // ConcurrentHashMap-only methods @@ -2116,9 +2167,9 @@ public class ConcurrentHashMap extends AbstractMap * @return the new set * @since 1.8 */ - public static KeySetView newKeySet() { - return new KeySetView - (new ConcurrentHashMap(), Boolean.TRUE); + public static KeySetView newKeySet() { + return new KeySetView + (new ConcurrentHashMap(), Boolean.TRUE); } /** @@ -2126,16 +2177,16 @@ public class ConcurrentHashMap extends AbstractMap * from the given type to {@code Boolean.TRUE}. * * @param initialCapacity The implementation performs internal - * sizing to accommodate this many elements. - * @param the element type of the returned set + * sizing to accommodate this many elements. + * @param the element type of the returned set * @return the new set * @throws IllegalArgumentException if the initial capacity of - * elements is negative + * elements is negative * @since 1.8 */ - public static KeySetView newKeySet(int initialCapacity) { - return new KeySetView - (new ConcurrentHashMap(initialCapacity), Boolean.TRUE); + public static KeySetView newKeySet(int initialCapacity) { + return new KeySetView + (new ConcurrentHashMap(initialCapacity), Boolean.TRUE); } /** @@ -2149,10 +2200,10 @@ public class ConcurrentHashMap extends AbstractMap * @return the set view * @throws NullPointerException if the mappedValue is null */ - public KeySetView keySet(V mappedValue) { + public KeySetView keySet(V mappedValue) { if (mappedValue == null) throw new NullPointerException(); - return new KeySetView(this, mappedValue); + return new KeySetView(this, mappedValue); } /* ---------------- Special Nodes -------------- */ @@ -2160,31 +2211,34 @@ public class ConcurrentHashMap extends AbstractMap /** * A node inserted at head of bins during transfer operations. */ - static final class ForwardingNode extends Node { - final Node[] nextTable; - ForwardingNode(Node[] tab) { + static final class ForwardingNode extends Node { + final Node[] nextTable; + + ForwardingNode(Node[] tab) { super(MOVED, null, null, null); this.nextTable = tab; } - Node find(int h, Object k) { + Node find(int h, Object k) { // loop to avoid arbitrarily deep recursion on forwarding nodes - outer: for (Node[] tab = nextTable;;) { - Node e; int n; + outer: + for (Node[] tab = nextTable; ; ) { + Node e; + int n; if (k == null || tab == null || (n = tab.length) == 0 || - (e = tabAt(tab, (n - 1) & h)) == null) + (e = tabAt(tab, (n - 1) & h)) == null) return null; - for (;;) { - int eh; K ek; + for (; ; ) { + int eh; + K ek; if ((eh = e.hash) == h && - ((ek = e.key) == k || (ek != null && k.equals(ek)))) + ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; if (eh < 0) { if (e instanceof ForwardingNode) { - tab = ((ForwardingNode)e).nextTable; + tab = ((ForwardingNode) e).nextTable; continue outer; - } - else + } else return e.find(h, k); } if ((e = e.next) == null) @@ -2197,12 +2251,12 @@ public class ConcurrentHashMap extends AbstractMap /** * A place-holder node used in computeIfAbsent and compute */ - static final class ReservationNode extends Node { + static final class ReservationNode extends Node { ReservationNode() { super(RESERVED, null, null, null); } - Node find(int h, Object k) { + Node find(int h, Object k) { return null; } } @@ -2220,8 +2274,9 @@ public class ConcurrentHashMap extends AbstractMap /** * Initializes table, using the size recorded in sizeCtl. */ - private final Node[] initTable() { - Node[] tab; int sc; + private final Node[] initTable() { + Node[] tab; + int sc; while ((tab = table) == null || tab.length == 0) { if ((sc = sizeCtl) < 0) Thread.yield(); // lost initialization race; just spin @@ -2230,7 +2285,7 @@ public class ConcurrentHashMap extends AbstractMap if ((tab = table) == null || tab.length == 0) { int n = (sc > 0) ? sc : DEFAULT_CAPACITY; @SuppressWarnings("unchecked") - Node[] nt = (Node[])new Node[n]; + Node[] nt = (Node[]) new Node[n]; table = tab = nt; sc = n - (n >>> 2); } @@ -2250,19 +2305,22 @@ public class ConcurrentHashMap extends AbstractMap * after a transfer to see if another resize is already needed * because resizings are lagging additions. * - * @param x the count to add + * @param x the count to add * @param check if <0, don't check resize, if <= 1 only check if uncontended */ private final void addCount(long x, int check) { - CounterCell[] as; long b, s; + CounterCell[] as; + long b, s; if ((as = counterCells) != null || - !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) { - CounterCell a; long v; int m; + !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) { + CounterCell a; + long v; + int m; boolean uncontended = true; if (as == null || (m = as.length - 1) < 0 || - (a = as[ThreadLocalRandom.getProbe() & m]) == null || - !(uncontended = - U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) { + (a = as[ThreadLocalRandom.getProbe() & m]) == null || + !(uncontended = + U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) { fullAddCount(x, uncontended); return; } @@ -2271,20 +2329,20 @@ public class ConcurrentHashMap extends AbstractMap s = sumCount(); } if (check >= 0) { - Node[] tab, nt; int n, sc; - while (s >= (long)(sc = sizeCtl) && (tab = table) != null && - (n = tab.length) < MAXIMUM_CAPACITY) { + Node[] tab, nt; + int n, sc; + while (s >= (long) (sc = sizeCtl) && (tab = table) != null && + (n = tab.length) < MAXIMUM_CAPACITY) { int rs = resizeStamp(n); if (sc < 0) { if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || - sc == rs + MAX_RESIZERS || (nt = nextTable) == null || - transferIndex <= 0) + sc == rs + MAX_RESIZERS || (nt = nextTable) == null || + transferIndex <= 0) break; if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) transfer(tab, nt); - } - else if (U.compareAndSwapInt(this, SIZECTL, sc, - (rs << RESIZE_STAMP_SHIFT) + 2)) + } else if (U.compareAndSwapInt(this, SIZECTL, sc, + (rs << RESIZE_STAMP_SHIFT) + 2)) transfer(tab, null); s = sumCount(); } @@ -2294,15 +2352,16 @@ public class ConcurrentHashMap extends AbstractMap /** * Helps transfer if a resize is in progress. */ - final Node[] helpTransfer(Node[] tab, Node f) { - Node[] nextTab; int sc; + final Node[] helpTransfer(Node[] tab, Node f) { + Node[] nextTab; + int sc; if (tab != null && (f instanceof ForwardingNode) && - (nextTab = ((ForwardingNode)f).nextTable) != null) { + (nextTab = ((ForwardingNode) f).nextTable) != null) { int rs = resizeStamp(tab.length); while (nextTab == nextTable && table == tab && - (sc = sizeCtl) < 0) { + (sc = sizeCtl) < 0) { if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || - sc == rs + MAX_RESIZERS || transferIndex <= 0) + sc == rs + MAX_RESIZERS || transferIndex <= 0) break; if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) { transfer(tab, nextTab); @@ -2321,17 +2380,18 @@ public class ConcurrentHashMap extends AbstractMap */ private final void tryPresize(int size) { int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : - tableSizeFor(size + (size >>> 1) + 1); + tableSizeFor(size + (size >>> 1) + 1); int sc; while ((sc = sizeCtl) >= 0) { - Node[] tab = table; int n; + Node[] tab = table; + int n; if (tab == null || (n = tab.length) == 0) { n = (sc > c) ? sc : c; if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { if (table == tab) { @SuppressWarnings("unchecked") - Node[] nt = (Node[])new Node[n]; + Node[] nt = (Node[]) new Node[n]; table = nt; sc = n - (n >>> 2); } @@ -2339,22 +2399,20 @@ public class ConcurrentHashMap extends AbstractMap sizeCtl = sc; } } - } - else if (c <= sc || n >= MAXIMUM_CAPACITY) + } else if (c <= sc || n >= MAXIMUM_CAPACITY) break; else if (tab == table) { int rs = resizeStamp(n); if (sc < 0) { - Node[] nt; + Node[] nt; if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || - sc == rs + MAX_RESIZERS || (nt = nextTable) == null || - transferIndex <= 0) + sc == rs + MAX_RESIZERS || (nt = nextTable) == null || + transferIndex <= 0) break; if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) transfer(tab, nt); - } - else if (U.compareAndSwapInt(this, SIZECTL, sc, - (rs << RESIZE_STAMP_SHIFT) + 2)) + } else if (U.compareAndSwapInt(this, SIZECTL, sc, + (rs << RESIZE_STAMP_SHIFT) + 2)) transfer(tab, null); } } @@ -2364,14 +2422,14 @@ public class ConcurrentHashMap extends AbstractMap * Moves and/or copies the nodes in each bin to new table. See * above for explanation. */ - private final void transfer(Node[] tab, Node[] nextTab) { + private final void transfer(Node[] tab, Node[] nextTab) { int n = tab.length, stride; if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) stride = MIN_TRANSFER_STRIDE; // subdivide range if (nextTab == null) { // initiating try { @SuppressWarnings("unchecked") - Node[] nt = (Node[])new Node[n << 1]; + Node[] nt = (Node[]) new Node[n << 1]; nextTab = nt; } catch (Throwable ex) { // try to cope with OOME sizeCtl = Integer.MAX_VALUE; @@ -2381,11 +2439,12 @@ public class ConcurrentHashMap extends AbstractMap transferIndex = n; } int nextn = nextTab.length; - ForwardingNode fwd = new ForwardingNode(nextTab); + ForwardingNode fwd = new ForwardingNode(nextTab); boolean advance = true; boolean finishing = false; // to ensure sweep before committing nextTab - for (int i = 0, bound = 0;;) { - Node f; int fh; + for (int i = 0, bound = 0; ; ) { + Node f; + int fh; while (advance) { int nextIndex, nextBound; if (--i >= bound || finishing) @@ -2393,11 +2452,10 @@ public class ConcurrentHashMap extends AbstractMap else if ((nextIndex = transferIndex) <= 0) { i = -1; advance = false; - } - else if (U.compareAndSwapInt - (this, TRANSFERINDEX, nextIndex, - nextBound = (nextIndex > stride ? - nextIndex - stride : 0))) { + } else if (U.compareAndSwapInt + (this, TRANSFERINDEX, nextIndex, + nextBound = (nextIndex > stride ? + nextIndex - stride : 0))) { bound = nextBound; i = nextIndex - 1; advance = false; @@ -2417,19 +2475,18 @@ public class ConcurrentHashMap extends AbstractMap finishing = advance = true; i = n; // recheck before commit } - } - else if ((f = tabAt(tab, i)) == null) + } else if ((f = tabAt(tab, i)) == null) advance = casTabAt(tab, i, null, fwd); else if ((fh = f.hash) == MOVED) advance = true; // already processed else { synchronized (f) { if (tabAt(tab, i) == f) { - Node ln, hn; + Node ln, hn; if (fh >= 0) { int runBit = fh & n; - Node lastRun = f; - for (Node p = f.next; p != null; p = p.next) { + Node lastRun = f; + for (Node p = f.next; p != null; p = p.next) { int b = p.hash & n; if (b != runBit) { runBit = b; @@ -2439,32 +2496,32 @@ public class ConcurrentHashMap extends AbstractMap if (runBit == 0) { ln = lastRun; hn = null; - } - else { + } else { hn = lastRun; ln = null; } - for (Node p = f; p != lastRun; p = p.next) { - int ph = p.hash; K pk = p.key; V pv = p.val; + for (Node p = f; p != lastRun; p = p.next) { + int ph = p.hash; + K pk = p.key; + V pv = p.val; if ((ph & n) == 0) - ln = new Node(ph, pk, pv, ln); + ln = new Node(ph, pk, pv, ln); else - hn = new Node(ph, pk, pv, hn); + hn = new Node(ph, pk, pv, hn); } setTabAt(nextTab, i, ln); setTabAt(nextTab, i + n, hn); setTabAt(tab, i, fwd); advance = true; - } - else if (f instanceof TreeBin) { - TreeBin t = (TreeBin)f; - TreeNode lo = null, loTail = null; - TreeNode hi = null, hiTail = null; + } else if (f instanceof TreeBin) { + TreeBin t = (TreeBin) f; + TreeNode lo = null, loTail = null; + TreeNode hi = null, hiTail = null; int lc = 0, hc = 0; - for (Node e = t.first; e != null; e = e.next) { + for (Node e = t.first; e != null; e = e.next) { int h = e.hash; - TreeNode p = new TreeNode - (h, e.key, e.val, null, null); + TreeNode p = new TreeNode + (h, e.key, e.val, null, null); if ((h & n) == 0) { if ((p.prev = loTail) == null) lo = p; @@ -2472,8 +2529,7 @@ public class ConcurrentHashMap extends AbstractMap loTail.next = p; loTail = p; ++lc; - } - else { + } else { if ((p.prev = hiTail) == null) hi = p; else @@ -2483,9 +2539,9 @@ public class ConcurrentHashMap extends AbstractMap } } ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : - (hc != 0) ? new TreeBin(lo) : t; + (hc != 0) ? new TreeBin(lo) : t; hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) : - (lc != 0) ? new TreeBin(hi) : t; + (lc != 0) ? new TreeBin(hi) : t; setTabAt(nextTab, i, ln); setTabAt(nextTab, i + n, hn); setTabAt(tab, i, fwd); @@ -2503,13 +2559,18 @@ public class ConcurrentHashMap extends AbstractMap * A padded cell for distributing counts. Adapted from LongAdder * and Striped64. See their internal docs for explanation. */ - @sun.misc.Contended static final class CounterCell { + @sun.misc.Contended + static final class CounterCell { volatile long value; - CounterCell(long x) { value = x; } + + CounterCell(long x) { + value = x; + } } final long sumCount() { - CounterCell[] as = counterCells; CounterCell a; + CounterCell[] as = counterCells; + CounterCell a; long sum = baseCount; if (as != null) { for (int i = 0; i < as.length; ++i) { @@ -2529,20 +2590,24 @@ public class ConcurrentHashMap extends AbstractMap wasUncontended = true; } boolean collide = false; // True if last slot nonempty - for (;;) { - CounterCell[] as; CounterCell a; int n; long v; + for (; ; ) { + CounterCell[] as; + CounterCell a; + int n; + long v; if ((as = counterCells) != null && (n = as.length) > 0) { if ((a = as[(n - 1) & h]) == null) { if (cellsBusy == 0) { // Try to attach new Cell CounterCell r = new CounterCell(x); // Optimistic create if (cellsBusy == 0 && - U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) { + U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) { boolean created = false; try { // Recheck under lock - CounterCell[] rs; int m, j; + CounterCell[] rs; + int m, j; if ((rs = counterCells) != null && - (m = rs.length) > 0 && - rs[j = (m - 1) & h] == null) { + (m = rs.length) > 0 && + rs[j = (m - 1) & h] == null) { rs[j] = r; created = true; } @@ -2555,8 +2620,7 @@ public class ConcurrentHashMap extends AbstractMap } } collide = false; - } - else if (!wasUncontended) // CAS already known to fail + } else if (!wasUncontended) // CAS already known to fail wasUncontended = true; // Continue after rehash else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)) break; @@ -2565,7 +2629,7 @@ public class ConcurrentHashMap extends AbstractMap else if (!collide) collide = true; else if (cellsBusy == 0 && - U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) { + U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) { try { if (counterCells == as) {// Expand table unless stale CounterCell[] rs = new CounterCell[n << 1]; @@ -2580,9 +2644,8 @@ public class ConcurrentHashMap extends AbstractMap continue; // Retry with expanded table } h = ThreadLocalRandom.advanceProbe(h); - } - else if (cellsBusy == 0 && counterCells == as && - U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) { + } else if (cellsBusy == 0 && counterCells == as && + U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) { boolean init = false; try { // Initialize table if (counterCells == as) { @@ -2596,8 +2659,7 @@ public class ConcurrentHashMap extends AbstractMap } if (init) break; - } - else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x)) + } else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x)) break; // Fall back on using base } } @@ -2608,26 +2670,27 @@ public class ConcurrentHashMap extends AbstractMap * Replaces all linked nodes in bin at given index unless table is * too small, in which case resizes instead. */ - private final void treeifyBin(Node[] tab, int index) { - Node b; int n, sc; + private final void treeifyBin(Node[] tab, int index) { + Node b; + int n, sc; if (tab != null) { if ((n = tab.length) < MIN_TREEIFY_CAPACITY) tryPresize(n << 1); else if ((b = tabAt(tab, index)) != null && b.hash >= 0) { synchronized (b) { if (tabAt(tab, index) == b) { - TreeNode hd = null, tl = null; - for (Node e = b; e != null; e = e.next) { - TreeNode p = - new TreeNode(e.hash, e.key, e.val, - null, null); + TreeNode hd = null, tl = null; + for (Node e = b; e != null; e = e.next) { + TreeNode p = + new TreeNode(e.hash, e.key, e.val, + null, null); if ((p.prev = tl) == null) hd = p; else tl.next = p; tl = p; } - setTabAt(tab, index, new TreeBin(hd)); + setTabAt(tab, index, new TreeBin(hd)); } } } @@ -2637,10 +2700,10 @@ public class ConcurrentHashMap extends AbstractMap /** * Returns a list on non-TreeNodes replacing those in given list. */ - static Node untreeify(Node b) { - Node hd = null, tl = null; - for (Node q = b; q != null; q = q.next) { - Node p = new Node(q.hash, q.key, q.val, null); + static Node untreeify(Node b) { + Node hd = null, tl = null; + for (Node q = b; q != null; q = q.next) { + Node p = new Node(q.hash, q.key, q.val, null); if (tl == null) hd = p; else @@ -2655,20 +2718,20 @@ public class ConcurrentHashMap extends AbstractMap /** * Nodes for use in TreeBins */ - static final class TreeNode extends Node { - TreeNode parent; // red-black tree links - TreeNode left; - TreeNode right; - TreeNode prev; // needed to unlink next upon deletion + static final class TreeNode extends Node { + TreeNode parent; // red-black tree links + TreeNode left; + TreeNode right; + TreeNode prev; // needed to unlink next upon deletion boolean red; - TreeNode(int hash, K key, V val, Node next, - TreeNode parent) { + TreeNode(int hash, K key, V val, Node next, + TreeNode parent) { super(hash, key, val, next); this.parent = parent; } - Node find(int h, Object k) { + Node find(int h, Object k) { return findTreeNode(h, k, null); } @@ -2676,12 +2739,14 @@ public class ConcurrentHashMap extends AbstractMap * Returns the TreeNode (or null if not found) for the given key * starting at given root. */ - final TreeNode findTreeNode(int h, Object k, Class kc) { + final TreeNode findTreeNode(int h, Object k, Class kc) { if (k != null) { - TreeNode p = this; - do { - int ph, dir; K pk; TreeNode q; - TreeNode pl = p.left, pr = p.right; + TreeNode p = this; + do { + int ph, dir; + K pk; + TreeNode q; + TreeNode pl = p.left, pr = p.right; if ((ph = p.hash) > h) p = pl; else if (ph < h) @@ -2693,8 +2758,8 @@ public class ConcurrentHashMap extends AbstractMap else if (pr == null) p = pl; else if ((kc != null || - (kc = comparableClassFor(k)) != null) && - (dir = compareComparables(kc, k, pk)) != 0) + (kc = comparableClassFor(k)) != null) && + (dir = compareComparables(kc, k, pk)) != 0) p = (dir < 0) ? pl : pr; else if ((q = pr.findTreeNode(h, k, kc)) != null) return q; @@ -2715,9 +2780,9 @@ public class ConcurrentHashMap extends AbstractMap * forcing writers (who hold bin lock) to wait for readers (who do * not) to complete before tree restructuring operations. */ - static final class TreeBin extends Node { - TreeNode root; - volatile TreeNode first; + static final class TreeBin extends Node { + TreeNode root; + volatile TreeNode first; volatile Thread waiter; volatile int lockState; // values for lockState @@ -2735,33 +2800,32 @@ public class ConcurrentHashMap extends AbstractMap static int tieBreakOrder(Object a, Object b) { int d; if (a == null || b == null || - (d = a.getClass().getName(). - compareTo(b.getClass().getName())) == 0) + (d = a.getClass().getName(). + compareTo(b.getClass().getName())) == 0) d = (System.identityHashCode(a) <= System.identityHashCode(b) ? - -1 : 1); + -1 : 1); return d; } /** * Creates bin with initial set of nodes headed by b. */ - TreeBin(TreeNode b) { + TreeBin(TreeNode b) { super(TREEBIN, null, null, null); this.first = b; - TreeNode r = null; - for (TreeNode x = b, next; x != null; x = next) { - next = (TreeNode)x.next; + TreeNode r = null; + for (TreeNode x = b, next; x != null; x = next) { + next = (TreeNode) x.next; x.left = x.right = null; if (r == null) { x.parent = null; x.red = false; r = x; - } - else { + } else { K k = x.key; int h = x.hash; Class kc = null; - for (TreeNode p = r;;) { + for (TreeNode p = r; ; ) { int dir, ph; K pk = p.key; if ((ph = p.hash) > h) @@ -2769,10 +2833,10 @@ public class ConcurrentHashMap extends AbstractMap else if (ph < h) dir = 1; else if ((kc == null && - (kc = comparableClassFor(k)) == null) || - (dir = compareComparables(kc, k, pk)) == 0) + (kc = comparableClassFor(k)) == null) || + (dir = compareComparables(kc, k, pk)) == 0) dir = tieBreakOrder(k, pk); - TreeNode xp = p; + TreeNode xp = p; if ((p = (dir <= 0) ? p.left : p.right) == null) { x.parent = xp; if (dir <= 0) @@ -2809,21 +2873,19 @@ public class ConcurrentHashMap extends AbstractMap */ private final void contendedLock() { boolean waiting = false; - for (int s;;) { + for (int s; ; ) { if (((s = lockState) & ~WAITER) == 0) { if (U.compareAndSwapInt(this, LOCKSTATE, s, WRITER)) { if (waiting) waiter = null; return; } - } - else if ((s & WAITER) == 0) { + } else if ((s & WAITER) == 0) { if (U.compareAndSwapInt(this, LOCKSTATE, s, s | WAITER)) { waiting = true; waiter = Thread.currentThread(); } - } - else if (waiting) + } else if (waiting) LockSupport.park(this); } } @@ -2833,26 +2895,26 @@ public class ConcurrentHashMap extends AbstractMap * using tree comparisons from root, but continues linear * search when lock not available. */ - final Node find(int h, Object k) { + final Node find(int h, Object k) { if (k != null) { - for (Node e = first; e != null; ) { - int s; K ek; - if (((s = lockState) & (WAITER|WRITER)) != 0) { + for (Node e = first; e != null; ) { + int s; + K ek; + if (((s = lockState) & (WAITER | WRITER)) != 0) { if (e.hash == h && - ((ek = e.key) == k || (ek != null && k.equals(ek)))) + ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; e = e.next; - } - else if (U.compareAndSwapInt(this, LOCKSTATE, s, - s + READER)) { - TreeNode r, p; + } else if (U.compareAndSwapInt(this, LOCKSTATE, s, + s + READER)) { + TreeNode r, p; try { p = ((r = root) == null ? null : - r.findTreeNode(h, k, null)); + r.findTreeNode(h, k, null)); } finally { Thread w; if (U.getAndAddInt(this, LOCKSTATE, -READER) == - (READER|WAITER) && (w = waiter) != null) + (READER | WAITER) && (w = waiter) != null) LockSupport.unpark(w); } return p; @@ -2864,42 +2926,43 @@ public class ConcurrentHashMap extends AbstractMap /** * Finds or adds a node. + * * @return null if added */ - final TreeNode putTreeVal(int h, K k, V v) { + final TreeNode putTreeVal(int h, K k, V v) { Class kc = null; boolean searched = false; - for (TreeNode p = root;;) { - int dir, ph; K pk; + for (TreeNode p = root; ; ) { + int dir, ph; + K pk; if (p == null) { - first = root = new TreeNode(h, k, v, null, null); + first = root = new TreeNode(h, k, v, null, null); break; - } - else if ((ph = p.hash) > h) + } else if ((ph = p.hash) > h) dir = -1; else if (ph < h) dir = 1; else if ((pk = p.key) == k || (pk != null && k.equals(pk))) return p; else if ((kc == null && - (kc = comparableClassFor(k)) == null) || - (dir = compareComparables(kc, k, pk)) == 0) { + (kc = comparableClassFor(k)) == null) || + (dir = compareComparables(kc, k, pk)) == 0) { if (!searched) { - TreeNode q, ch; + TreeNode q, ch; searched = true; if (((ch = p.left) != null && - (q = ch.findTreeNode(h, k, kc)) != null) || - ((ch = p.right) != null && - (q = ch.findTreeNode(h, k, kc)) != null)) + (q = ch.findTreeNode(h, k, kc)) != null) || + ((ch = p.right) != null && + (q = ch.findTreeNode(h, k, kc)) != null)) return q; } dir = tieBreakOrder(k, pk); } - TreeNode xp = p; + TreeNode xp = p; if ((p = (dir <= 0) ? p.left : p.right) == null) { - TreeNode x, f = first; - first = x = new TreeNode(h, k, v, f, xp); + TreeNode x, f = first; + first = x = new TreeNode(h, k, v, f, xp); if (f != null) f.prev = x; if (dir <= 0) @@ -2933,10 +2996,10 @@ public class ConcurrentHashMap extends AbstractMap * * @return true if now too small, so should be untreeified */ - final boolean removeTreeNode(TreeNode p) { - TreeNode next = (TreeNode)p.next; - TreeNode pred = p.prev; // unlink traversal pointers - TreeNode r, rl; + final boolean removeTreeNode(TreeNode p) { + TreeNode next = (TreeNode) p.next; + TreeNode pred = p.prev; // unlink traversal pointers + TreeNode r, rl; if (pred == null) first = next; else @@ -2948,26 +3011,27 @@ public class ConcurrentHashMap extends AbstractMap return true; } if ((r = root) == null || r.right == null || // too small - (rl = r.left) == null || rl.left == null) + (rl = r.left) == null || rl.left == null) return true; lockRoot(); try { - TreeNode replacement; - TreeNode pl = p.left; - TreeNode pr = p.right; + TreeNode replacement; + TreeNode pl = p.left; + TreeNode pr = p.right; if (pl != null && pr != null) { - TreeNode s = pr, sl; + TreeNode s = pr, sl; while ((sl = s.left) != null) // find successor s = sl; - boolean c = s.red; s.red = p.red; p.red = c; // swap colors - TreeNode sr = s.right; - TreeNode pp = p.parent; + boolean c = s.red; + s.red = p.red; + p.red = c; // swap colors + TreeNode sr = s.right; + TreeNode pp = p.parent; if (s == pr) { // p was s's direct parent p.parent = s; s.right = p; - } - else { - TreeNode sp = s.parent; + } else { + TreeNode sp = s.parent; if ((p.parent = sp) != null) { if (s == sp.left) sp.left = p; @@ -2992,15 +3056,14 @@ public class ConcurrentHashMap extends AbstractMap replacement = sr; else replacement = p; - } - else if (pl != null) + } else if (pl != null) replacement = pl; else if (pr != null) replacement = pr; else replacement = p; if (replacement != p) { - TreeNode pp = replacement.parent = p.parent; + TreeNode pp = replacement.parent = p.parent; if (pp == null) r = replacement; else if (p == pp.left) @@ -3013,7 +3076,7 @@ public class ConcurrentHashMap extends AbstractMap root = (p.red) ? r : balanceDeletion(r, replacement); if (p == replacement) { // detach pointers - TreeNode pp; + TreeNode pp; if ((pp = p.parent) != null) { if (p == pp.left) pp.left = null; @@ -3032,9 +3095,9 @@ public class ConcurrentHashMap extends AbstractMap /* ------------------------------------------------------------ */ // Red-black tree methods, all adapted from CLR - static TreeNode rotateLeft(TreeNode root, - TreeNode p) { - TreeNode r, pp, rl; + static TreeNode rotateLeft(TreeNode root, + TreeNode p) { + TreeNode r, pp, rl; if (p != null && (r = p.right) != null) { if ((rl = p.right = r.left) != null) rl.parent = p; @@ -3050,9 +3113,9 @@ public class ConcurrentHashMap extends AbstractMap return root; } - static TreeNode rotateRight(TreeNode root, - TreeNode p) { - TreeNode l, pp, lr; + static TreeNode rotateRight(TreeNode root, + TreeNode p) { + TreeNode l, pp, lr; if (p != null && (l = p.left) != null) { if ((lr = p.left = l.right) != null) lr.parent = p; @@ -3068,15 +3131,14 @@ public class ConcurrentHashMap extends AbstractMap return root; } - static TreeNode balanceInsertion(TreeNode root, - TreeNode x) { + static TreeNode balanceInsertion(TreeNode root, + TreeNode x) { x.red = true; - for (TreeNode xp, xpp, xppl, xppr;;) { + for (TreeNode xp, xpp, xppl, xppr; ; ) { if ((xp = x.parent) == null) { x.red = false; return x; - } - else if (!xp.red || (xpp = xp.parent) == null) + } else if (!xp.red || (xpp = xp.parent) == null) return root; if (xp == (xppl = xpp.left)) { if ((xppr = xpp.right) != null && xppr.red) { @@ -3084,8 +3146,7 @@ public class ConcurrentHashMap extends AbstractMap xp.red = false; xpp.red = true; x = xpp; - } - else { + } else { if (x == xp.right) { root = rotateLeft(root, x = xp); xpp = (xp = x.parent) == null ? null : xp.parent; @@ -3098,15 +3159,13 @@ public class ConcurrentHashMap extends AbstractMap } } } - } - else { + } else { if (xppl != null && xppl.red) { xppl.red = false; xp.red = false; xpp.red = true; x = xpp; - } - else { + } else { if (x == xp.left) { root = rotateRight(root, x = xp); xpp = (xp = x.parent) == null ? null : xp.parent; @@ -3123,20 +3182,18 @@ public class ConcurrentHashMap extends AbstractMap } } - static TreeNode balanceDeletion(TreeNode root, - TreeNode x) { - for (TreeNode xp, xpl, xpr;;) { + static TreeNode balanceDeletion(TreeNode root, + TreeNode x) { + for (TreeNode xp, xpl, xpr; ; ) { if (x == null || x == root) return root; else if ((xp = x.parent) == null) { x.red = false; return x; - } - else if (x.red) { + } else if (x.red) { x.red = false; return root; - } - else if ((xpl = xp.left) == x) { + } else if ((xpl = xp.left) == x) { if ((xpr = xp.right) != null && xpr.red) { xpr.red = false; xp.red = true; @@ -3146,20 +3203,19 @@ public class ConcurrentHashMap extends AbstractMap if (xpr == null) x = xp; else { - TreeNode sl = xpr.left, sr = xpr.right; + TreeNode sl = xpr.left, sr = xpr.right; if ((sr == null || !sr.red) && - (sl == null || !sl.red)) { + (sl == null || !sl.red)) { xpr.red = true; x = xp; - } - else { + } else { if (sr == null || !sr.red) { if (sl != null) sl.red = false; xpr.red = true; root = rotateRight(root, xpr); xpr = (xp = x.parent) == null ? - null : xp.right; + null : xp.right; } if (xpr != null) { xpr.red = (xp == null) ? false : xp.red; @@ -3173,8 +3229,7 @@ public class ConcurrentHashMap extends AbstractMap x = root; } } - } - else { // symmetric + } else { // symmetric if (xpl != null && xpl.red) { xpl.red = false; xp.red = true; @@ -3184,20 +3239,19 @@ public class ConcurrentHashMap extends AbstractMap if (xpl == null) x = xp; else { - TreeNode sl = xpl.left, sr = xpl.right; + TreeNode sl = xpl.left, sr = xpl.right; if ((sl == null || !sl.red) && - (sr == null || !sr.red)) { + (sr == null || !sr.red)) { xpl.red = true; x = xp; - } - else { + } else { if (sl == null || !sl.red) { if (sr != null) sr.red = false; xpl.red = true; root = rotateLeft(root, xpl); xpl = (xp = x.parent) == null ? - null : xp.left; + null : xp.left; } if (xpl != null) { xpl.red = (xp == null) ? false : xp.red; @@ -3218,9 +3272,9 @@ public class ConcurrentHashMap extends AbstractMap /** * Recursive invariant check */ - static boolean checkInvariants(TreeNode t) { - TreeNode tp = t.parent, tl = t.left, tr = t.right, - tb = t.prev, tn = (TreeNode)t.next; + static boolean checkInvariants(TreeNode t) { + TreeNode tp = t.parent, tl = t.left, tr = t.right, + tb = t.prev, tn = (TreeNode) t.next; if (tb != null && tb.next != t) return false; if (tn != null && tn.prev != t) @@ -3242,12 +3296,13 @@ public class ConcurrentHashMap extends AbstractMap private static final sun.misc.Unsafe U; private static final long LOCKSTATE; + static { try { U = sun.misc.Unsafe.getUnsafe(); Class k = TreeBin.class; LOCKSTATE = U.objectFieldOffset - (k.getDeclaredField("lockState")); + (k.getDeclaredField("lockState")); } catch (Exception e) { throw new Error(e); } @@ -3261,17 +3316,17 @@ public class ConcurrentHashMap extends AbstractMap * traverser that must process a region of a forwarded table before * proceeding with current table. */ - static final class TableStack { + static final class TableStack { int length; int index; - Node[] tab; - TableStack next; + Node[] tab; + TableStack next; } /** * Encapsulates traversal for methods such as containsValue; also * serves as a base class for other iterators and spliterators. - * + *

* Method advance visits once each still-valid node that was * reachable upon iterator construction. It might miss some that * were added to a bin after the bin was visited, which is OK wrt @@ -3280,7 +3335,7 @@ public class ConcurrentHashMap extends AbstractMap * bookkeeping state that is difficult to optimize away amidst * volatile accesses. Even so, traversal maintains reasonable * throughput. - * + *

* Normally, iteration proceeds bin-by-bin traversing lists. * However, if the table has been resized, then all future steps * must traverse both the bin at the current index as well as at @@ -3289,16 +3344,16 @@ public class ConcurrentHashMap extends AbstractMap * across threads, iteration terminates if a bounds checks fails * for a table read. */ - static class Traverser { - Node[] tab; // current table; updated if resized - Node next; // the next entry to use - TableStack stack, spare; // to save/restore on ForwardingNodes + static class Traverser { + Node[] tab; // current table; updated if resized + Node next; // the next entry to use + TableStack stack, spare; // to save/restore on ForwardingNodes int index; // index of bin to use next int baseIndex; // current index of initial table int baseLimit; // index bound for initial table final int baseSize; // initial table size - Traverser(Node[] tab, int size, int index, int limit) { + Traverser(Node[] tab, int size, int index, int limit) { this.tab = tab; this.baseSize = size; this.baseIndex = this.index = index; @@ -3309,26 +3364,26 @@ public class ConcurrentHashMap extends AbstractMap /** * Advances if possible, returning next valid node, or null if none. */ - final Node advance() { - Node e; + final Node advance() { + Node e; if ((e = next) != null) e = e.next; - for (;;) { - Node[] t; int i, n; // must use locals in checks + for (; ; ) { + Node[] t; + int i, n; // must use locals in checks if (e != null) return next = e; if (baseIndex >= baseLimit || (t = tab) == null || - (n = t.length) <= (i = index) || i < 0) + (n = t.length) <= (i = index) || i < 0) return next = null; if ((e = tabAt(t, i)) != null && e.hash < 0) { if (e instanceof ForwardingNode) { - tab = ((ForwardingNode)e).nextTable; + tab = ((ForwardingNode) e).nextTable; e = null; pushState(t, i, n); continue; - } - else if (e instanceof TreeBin) - e = ((TreeBin)e).first; + } else if (e instanceof TreeBin) + e = ((TreeBin) e).first; else e = null; } @@ -3342,12 +3397,12 @@ public class ConcurrentHashMap extends AbstractMap /** * Saves traversal state upon encountering a forwarding node. */ - private void pushState(Node[] t, int i, int n) { - TableStack s = spare; // reuse if possible + private void pushState(Node[] t, int i, int n) { + TableStack s = spare; // reuse if possible if (s != null) spare = s.next; else - s = new TableStack(); + s = new TableStack(); s.tab = t; s.length = n; s.index = i; @@ -3361,13 +3416,14 @@ public class ConcurrentHashMap extends AbstractMap * @param n length of current table */ private void recoverState(int n) { - TableStack s; int len; + TableStack s; + int len; while ((s = stack) != null && (index += (len = s.length)) >= n) { n = len; index = s.index; tab = s.tab; s.tab = null; - TableStack next = s.next; + TableStack next = s.next; s.next = spare; // save for reuse stack = next; spare = s; @@ -3381,21 +3437,27 @@ public class ConcurrentHashMap extends AbstractMap * Base of key, value, and entry Iterators. Adds fields to * Traverser to support iterator.remove. */ - static class BaseIterator extends Traverser { - final ConcurrentHashMap map; - Node lastReturned; - BaseIterator(Node[] tab, int size, int index, int limit, - ConcurrentHashMap map) { + static class BaseIterator extends Traverser { + final ConcurrentHashMap map; + Node lastReturned; + + BaseIterator(Node[] tab, int size, int index, int limit, + ConcurrentHashMap map) { super(tab, size, index, limit); this.map = map; advance(); } - public final boolean hasNext() { return next != null; } - public final boolean hasMoreElements() { return next != null; } + public final boolean hasNext() { + return next != null; + } + + public final boolean hasMoreElements() { + return next != null; + } public final void remove() { - Node p; + Node p; if ((p = lastReturned) == null) throw new IllegalStateException(); lastReturned = null; @@ -3403,15 +3465,15 @@ public class ConcurrentHashMap extends AbstractMap } } - static final class KeyIterator extends BaseIterator - implements Iterator, Enumeration { - KeyIterator(Node[] tab, int index, int size, int limit, - ConcurrentHashMap map) { + static final class KeyIterator extends BaseIterator + implements Iterator, Enumeration { + KeyIterator(Node[] tab, int index, int size, int limit, + ConcurrentHashMap map) { super(tab, index, size, limit, map); } public final K next() { - Node p; + Node p; if ((p = next) == null) throw new NoSuchElementException(); K k = p.key; @@ -3420,18 +3482,20 @@ public class ConcurrentHashMap extends AbstractMap return k; } - public final K nextElement() { return next(); } + public final K nextElement() { + return next(); + } } - static final class ValueIterator extends BaseIterator - implements Iterator, Enumeration { - ValueIterator(Node[] tab, int index, int size, int limit, - ConcurrentHashMap map) { + static final class ValueIterator extends BaseIterator + implements Iterator, Enumeration { + ValueIterator(Node[] tab, int index, int size, int limit, + ConcurrentHashMap map) { super(tab, index, size, limit, map); } public final V next() { - Node p; + Node p; if ((p = next) == null) throw new NoSuchElementException(); V v = p.val; @@ -3440,49 +3504,65 @@ public class ConcurrentHashMap extends AbstractMap return v; } - public final V nextElement() { return next(); } + public final V nextElement() { + return next(); + } } - static final class EntryIterator extends BaseIterator - implements Iterator> { - EntryIterator(Node[] tab, int index, int size, int limit, - ConcurrentHashMap map) { + static final class EntryIterator extends BaseIterator + implements Iterator> { + EntryIterator(Node[] tab, int index, int size, int limit, + ConcurrentHashMap map) { super(tab, index, size, limit, map); } - public final Map.Entry next() { - Node p; + public final Map.Entry next() { + Node p; if ((p = next) == null) throw new NoSuchElementException(); K k = p.key; V v = p.val; lastReturned = p; advance(); - return new MapEntry(k, v, map); + return new MapEntry(k, v, map); } } /** * Exported Entry for EntryIterator */ - static final class MapEntry implements Map.Entry { + static final class MapEntry implements Map.Entry { final K key; // non-null V val; // non-null - final ConcurrentHashMap map; - MapEntry(K key, V val, ConcurrentHashMap map) { + final ConcurrentHashMap map; + + MapEntry(K key, V val, ConcurrentHashMap map) { this.key = key; this.val = val; this.map = map; } - public K getKey() { return key; } - public V getValue() { return val; } - public int hashCode() { return key.hashCode() ^ val.hashCode(); } - public String toString() { return key + "=" + val; } + + public K getKey() { + return key; + } + + public V getValue() { + return val; + } + + public int hashCode() { + return key.hashCode() ^ val.hashCode(); + } + + public String toString() { + return key + "=" + val; + } public boolean equals(Object o) { - Object k, v; Map.Entry e; + Object k, v; + Map.Entry e; return ((o instanceof Map.Entry) && - (k = (e = (Map.Entry)o).getKey()) != null && + (k = (e = (Map.Entry) o).getKey()) != null && (v = e.getValue()) != null && (k == key || k.equals(key)) && (v == val || v.equals(val))); @@ -3505,10 +3585,11 @@ public class ConcurrentHashMap extends AbstractMap } } - static final class KeySpliterator extends Traverser - implements Spliterator { + static final class KeySpliterator extends Traverser + implements Spliterator { long est; // size estimate - KeySpliterator(Node[] tab, int size, int index, int limit, + + KeySpliterator(Node[] tab, int size, int index, int limit, long est) { super(tab, size, index, limit); this.est = est; @@ -3517,37 +3598,40 @@ public class ConcurrentHashMap extends AbstractMap public Spliterator trySplit() { int i, f, h; return (h = ((i = baseIndex) + (f = baseLimit)) >>> 1) <= i ? null : - new KeySpliterator(tab, baseSize, baseLimit = h, - f, est >>>= 1); + new KeySpliterator(tab, baseSize, baseLimit = h, + f, est >>>= 1); } public void forEachRemaining(Consumer action) { if (action == null) throw new NullPointerException(); - for (Node p; (p = advance()) != null;) + for (Node p; (p = advance()) != null; ) action.accept(p.key); } public boolean tryAdvance(Consumer action) { if (action == null) throw new NullPointerException(); - Node p; + Node p; if ((p = advance()) == null) return false; action.accept(p.key); return true; } - public long estimateSize() { return est; } + public long estimateSize() { + return est; + } public int characteristics() { return Spliterator.DISTINCT | Spliterator.CONCURRENT | - Spliterator.NONNULL; + Spliterator.NONNULL; } } - static final class ValueSpliterator extends Traverser - implements Spliterator { + static final class ValueSpliterator extends Traverser + implements Spliterator { long est; // size estimate - ValueSpliterator(Node[] tab, int size, int index, int limit, + + ValueSpliterator(Node[] tab, int size, int index, int limit, long est) { super(tab, size, index, limit); this.est = est; @@ -3556,70 +3640,75 @@ public class ConcurrentHashMap extends AbstractMap public Spliterator trySplit() { int i, f, h; return (h = ((i = baseIndex) + (f = baseLimit)) >>> 1) <= i ? null : - new ValueSpliterator(tab, baseSize, baseLimit = h, - f, est >>>= 1); + new ValueSpliterator(tab, baseSize, baseLimit = h, + f, est >>>= 1); } public void forEachRemaining(Consumer action) { if (action == null) throw new NullPointerException(); - for (Node p; (p = advance()) != null;) + for (Node p; (p = advance()) != null; ) action.accept(p.val); } public boolean tryAdvance(Consumer action) { if (action == null) throw new NullPointerException(); - Node p; + Node p; if ((p = advance()) == null) return false; action.accept(p.val); return true; } - public long estimateSize() { return est; } + public long estimateSize() { + return est; + } public int characteristics() { return Spliterator.CONCURRENT | Spliterator.NONNULL; } } - static final class EntrySpliterator extends Traverser - implements Spliterator> { - final ConcurrentHashMap map; // To export MapEntry + static final class EntrySpliterator extends Traverser + implements Spliterator> { + final ConcurrentHashMap map; // To export MapEntry long est; // size estimate - EntrySpliterator(Node[] tab, int size, int index, int limit, - long est, ConcurrentHashMap map) { + + EntrySpliterator(Node[] tab, int size, int index, int limit, + long est, ConcurrentHashMap map) { super(tab, size, index, limit); this.map = map; this.est = est; } - public Spliterator> trySplit() { + public Spliterator> trySplit() { int i, f, h; return (h = ((i = baseIndex) + (f = baseLimit)) >>> 1) <= i ? null : - new EntrySpliterator(tab, baseSize, baseLimit = h, - f, est >>>= 1, map); + new EntrySpliterator(tab, baseSize, baseLimit = h, + f, est >>>= 1, map); } - public void forEachRemaining(Consumer> action) { + public void forEachRemaining(Consumer> action) { if (action == null) throw new NullPointerException(); - for (Node p; (p = advance()) != null; ) - action.accept(new MapEntry(p.key, p.val, map)); + for (Node p; (p = advance()) != null; ) + action.accept(new MapEntry(p.key, p.val, map)); } - public boolean tryAdvance(Consumer> action) { + public boolean tryAdvance(Consumer> action) { if (action == null) throw new NullPointerException(); - Node p; + Node p; if ((p = advance()) == null) return false; - action.accept(new MapEntry(p.key, p.val, map)); + action.accept(new MapEntry(p.key, p.val, map)); return true; } - public long estimateSize() { return est; } + public long estimateSize() { + return est; + } public int characteristics() { return Spliterator.DISTINCT | Spliterator.CONCURRENT | - Spliterator.NONNULL; + Spliterator.NONNULL; } } @@ -3638,23 +3727,23 @@ public class ConcurrentHashMap extends AbstractMap if (b == Long.MAX_VALUE || (n = sumCount()) <= 1L || n < b) return 0; int sp = ForkJoinPool.getCommonPoolParallelism() << 2; // slack of 4 - return (b <= 0L || (n /= b) >= sp) ? sp : (int)n; + return (b <= 0L || (n /= b) >= sp) ? sp : (int) n; } /** * Performs the given action for each (key, value). * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param action the action + * needed for this operation to be executed in parallel + * @param action the action * @since 1.8 */ public void forEach(long parallelismThreshold, - BiConsumer action) { + BiConsumer action) { if (action == null) throw new NullPointerException(); - new ForEachMappingTask - (null, batchFor(parallelismThreshold), 0, 0, table, - action).invoke(); + new ForEachMappingTask + (null, batchFor(parallelismThreshold), 0, 0, table, + action).invoke(); } /** @@ -3662,12 +3751,12 @@ public class ConcurrentHashMap extends AbstractMap * of each (key, value). * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element, or null if there is no transformation (in - * which case the action is not applied) - * @param action the action - * @param the return type of the transformer + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element, or null if there is no transformation (in + * which case the action is not applied) + * @param action the action + * @param the return type of the transformer * @since 1.8 */ public void forEach(long parallelismThreshold, @@ -3675,9 +3764,9 @@ public class ConcurrentHashMap extends AbstractMap Consumer action) { if (transformer == null || action == null) throw new NullPointerException(); - new ForEachTransformedMappingTask - (null, batchFor(parallelismThreshold), 0, 0, table, - transformer, action).invoke(); + new ForEachTransformedMappingTask + (null, batchFor(parallelismThreshold), 0, 0, table, + transformer, action).invoke(); } /** @@ -3688,10 +3777,10 @@ public class ConcurrentHashMap extends AbstractMap * function are ignored. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param searchFunction a function returning a non-null - * result on success, else null - * @param the return type of the search function + * needed for this operation to be executed in parallel + * @param searchFunction a function returning a non-null + * result on success, else null + * @param the return type of the search function * @return a non-null result from applying the given search * function on each (key, value), or null if none * @since 1.8 @@ -3699,9 +3788,9 @@ public class ConcurrentHashMap extends AbstractMap public U search(long parallelismThreshold, BiFunction searchFunction) { if (searchFunction == null) throw new NullPointerException(); - return new SearchMappingsTask - (null, batchFor(parallelismThreshold), 0, 0, table, - searchFunction, new AtomicReference()).invoke(); + return new SearchMappingsTask + (null, batchFor(parallelismThreshold), 0, 0, table, + searchFunction, new AtomicReference()).invoke(); } /** @@ -3710,12 +3799,12 @@ public class ConcurrentHashMap extends AbstractMap * combine values, or null if none. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element, or null if there is no transformation (in - * which case it is not combined) - * @param reducer a commutative associative combining function - * @param the return type of the transformer + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element, or null if there is no transformation (in + * which case it is not combined) + * @param reducer a commutative associative combining function + * @param the return type of the transformer * @return the result of accumulating the given transformation * of all (key, value) pairs * @since 1.8 @@ -3725,9 +3814,9 @@ public class ConcurrentHashMap extends AbstractMap BiFunction reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceMappingsTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, reducer).invoke(); + return new MapReduceMappingsTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, reducer).invoke(); } /** @@ -3736,11 +3825,11 @@ public class ConcurrentHashMap extends AbstractMap * combine values, and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all (key, value) pairs * @since 1.8 @@ -3751,9 +3840,9 @@ public class ConcurrentHashMap extends AbstractMap DoubleBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceMappingsToDoubleTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceMappingsToDoubleTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** @@ -3762,11 +3851,11 @@ public class ConcurrentHashMap extends AbstractMap * combine values, and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all (key, value) pairs * @since 1.8 @@ -3777,9 +3866,9 @@ public class ConcurrentHashMap extends AbstractMap LongBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceMappingsToLongTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceMappingsToLongTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** @@ -3788,11 +3877,11 @@ public class ConcurrentHashMap extends AbstractMap * combine values, and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all (key, value) pairs * @since 1.8 @@ -3803,25 +3892,25 @@ public class ConcurrentHashMap extends AbstractMap IntBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceMappingsToIntTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceMappingsToIntTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** * Performs the given action for each key. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param action the action + * needed for this operation to be executed in parallel + * @param action the action * @since 1.8 */ public void forEachKey(long parallelismThreshold, Consumer action) { if (action == null) throw new NullPointerException(); - new ForEachKeyTask - (null, batchFor(parallelismThreshold), 0, 0, table, - action).invoke(); + new ForEachKeyTask + (null, batchFor(parallelismThreshold), 0, 0, table, + action).invoke(); } /** @@ -3829,12 +3918,12 @@ public class ConcurrentHashMap extends AbstractMap * of each key. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element, or null if there is no transformation (in - * which case the action is not applied) - * @param action the action - * @param the return type of the transformer + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element, or null if there is no transformation (in + * which case the action is not applied) + * @param action the action + * @param the return type of the transformer * @since 1.8 */ public void forEachKey(long parallelismThreshold, @@ -3842,9 +3931,9 @@ public class ConcurrentHashMap extends AbstractMap Consumer action) { if (transformer == null || action == null) throw new NullPointerException(); - new ForEachTransformedKeyTask - (null, batchFor(parallelismThreshold), 0, 0, table, - transformer, action).invoke(); + new ForEachTransformedKeyTask + (null, batchFor(parallelismThreshold), 0, 0, table, + transformer, action).invoke(); } /** @@ -3855,10 +3944,10 @@ public class ConcurrentHashMap extends AbstractMap * ignored. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param searchFunction a function returning a non-null - * result on success, else null - * @param the return type of the search function + * needed for this operation to be executed in parallel + * @param searchFunction a function returning a non-null + * result on success, else null + * @param the return type of the search function * @return a non-null result from applying the given search * function on each key, or null if none * @since 1.8 @@ -3866,9 +3955,9 @@ public class ConcurrentHashMap extends AbstractMap public U searchKeys(long parallelismThreshold, Function searchFunction) { if (searchFunction == null) throw new NullPointerException(); - return new SearchKeysTask - (null, batchFor(parallelismThreshold), 0, 0, table, - searchFunction, new AtomicReference()).invoke(); + return new SearchKeysTask + (null, batchFor(parallelismThreshold), 0, 0, table, + searchFunction, new AtomicReference()).invoke(); } /** @@ -3876,8 +3965,8 @@ public class ConcurrentHashMap extends AbstractMap * reducer to combine values, or null if none. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param reducer a commutative associative combining function * @return the result of accumulating all keys using the given * reducer to combine values, or null if none * @since 1.8 @@ -3885,9 +3974,9 @@ public class ConcurrentHashMap extends AbstractMap public K reduceKeys(long parallelismThreshold, BiFunction reducer) { if (reducer == null) throw new NullPointerException(); - return new ReduceKeysTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, reducer).invoke(); + return new ReduceKeysTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, reducer).invoke(); } /** @@ -3896,24 +3985,24 @@ public class ConcurrentHashMap extends AbstractMap * null if none. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element, or null if there is no transformation (in - * which case it is not combined) - * @param reducer a commutative associative combining function - * @param the return type of the transformer + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element, or null if there is no transformation (in + * which case it is not combined) + * @param reducer a commutative associative combining function + * @param the return type of the transformer * @return the result of accumulating the given transformation * of all keys * @since 1.8 */ public U reduceKeys(long parallelismThreshold, Function transformer, - BiFunction reducer) { + BiFunction reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceKeysTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, reducer).invoke(); + return new MapReduceKeysTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, reducer).invoke(); } /** @@ -3922,11 +4011,11 @@ public class ConcurrentHashMap extends AbstractMap * the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all keys * @since 1.8 @@ -3937,9 +4026,9 @@ public class ConcurrentHashMap extends AbstractMap DoubleBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceKeysToDoubleTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceKeysToDoubleTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** @@ -3948,11 +4037,11 @@ public class ConcurrentHashMap extends AbstractMap * the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all keys * @since 1.8 @@ -3963,9 +4052,9 @@ public class ConcurrentHashMap extends AbstractMap LongBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceKeysToLongTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceKeysToLongTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** @@ -3974,11 +4063,11 @@ public class ConcurrentHashMap extends AbstractMap * the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all keys * @since 1.8 @@ -3989,26 +4078,26 @@ public class ConcurrentHashMap extends AbstractMap IntBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceKeysToIntTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceKeysToIntTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** * Performs the given action for each value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param action the action + * needed for this operation to be executed in parallel + * @param action the action * @since 1.8 */ public void forEachValue(long parallelismThreshold, Consumer action) { if (action == null) throw new NullPointerException(); - new ForEachValueTask - (null, batchFor(parallelismThreshold), 0, 0, table, - action).invoke(); + new ForEachValueTask + (null, batchFor(parallelismThreshold), 0, 0, table, + action).invoke(); } /** @@ -4016,12 +4105,12 @@ public class ConcurrentHashMap extends AbstractMap * of each value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element, or null if there is no transformation (in - * which case the action is not applied) - * @param action the action - * @param the return type of the transformer + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element, or null if there is no transformation (in + * which case the action is not applied) + * @param action the action + * @param the return type of the transformer * @since 1.8 */ public void forEachValue(long parallelismThreshold, @@ -4029,9 +4118,9 @@ public class ConcurrentHashMap extends AbstractMap Consumer action) { if (transformer == null || action == null) throw new NullPointerException(); - new ForEachTransformedValueTask - (null, batchFor(parallelismThreshold), 0, 0, table, - transformer, action).invoke(); + new ForEachTransformedValueTask + (null, batchFor(parallelismThreshold), 0, 0, table, + transformer, action).invoke(); } /** @@ -4042,10 +4131,10 @@ public class ConcurrentHashMap extends AbstractMap * ignored. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param searchFunction a function returning a non-null - * result on success, else null - * @param the return type of the search function + * needed for this operation to be executed in parallel + * @param searchFunction a function returning a non-null + * result on success, else null + * @param the return type of the search function * @return a non-null result from applying the given search * function on each value, or null if none * @since 1.8 @@ -4053,9 +4142,9 @@ public class ConcurrentHashMap extends AbstractMap public U searchValues(long parallelismThreshold, Function searchFunction) { if (searchFunction == null) throw new NullPointerException(); - return new SearchValuesTask - (null, batchFor(parallelismThreshold), 0, 0, table, - searchFunction, new AtomicReference()).invoke(); + return new SearchValuesTask + (null, batchFor(parallelismThreshold), 0, 0, table, + searchFunction, new AtomicReference()).invoke(); } /** @@ -4063,17 +4152,17 @@ public class ConcurrentHashMap extends AbstractMap * given reducer to combine values, or null if none. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param reducer a commutative associative combining function * @return the result of accumulating all values * @since 1.8 */ public V reduceValues(long parallelismThreshold, BiFunction reducer) { if (reducer == null) throw new NullPointerException(); - return new ReduceValuesTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, reducer).invoke(); + return new ReduceValuesTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, reducer).invoke(); } /** @@ -4082,12 +4171,12 @@ public class ConcurrentHashMap extends AbstractMap * null if none. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element, or null if there is no transformation (in - * which case it is not combined) - * @param reducer a commutative associative combining function - * @param the return type of the transformer + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element, or null if there is no transformation (in + * which case it is not combined) + * @param reducer a commutative associative combining function + * @param the return type of the transformer * @return the result of accumulating the given transformation * of all values * @since 1.8 @@ -4097,9 +4186,9 @@ public class ConcurrentHashMap extends AbstractMap BiFunction reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceValuesTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, reducer).invoke(); + return new MapReduceValuesTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, reducer).invoke(); } /** @@ -4108,11 +4197,11 @@ public class ConcurrentHashMap extends AbstractMap * and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all values * @since 1.8 @@ -4123,9 +4212,9 @@ public class ConcurrentHashMap extends AbstractMap DoubleBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceValuesToDoubleTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceValuesToDoubleTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** @@ -4134,11 +4223,11 @@ public class ConcurrentHashMap extends AbstractMap * and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all values * @since 1.8 @@ -4149,9 +4238,9 @@ public class ConcurrentHashMap extends AbstractMap LongBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceValuesToLongTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceValuesToLongTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** @@ -4160,11 +4249,11 @@ public class ConcurrentHashMap extends AbstractMap * and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all values * @since 1.8 @@ -4175,24 +4264,24 @@ public class ConcurrentHashMap extends AbstractMap IntBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceValuesToIntTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceValuesToIntTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** * Performs the given action for each entry. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param action the action + * needed for this operation to be executed in parallel + * @param action the action * @since 1.8 */ public void forEachEntry(long parallelismThreshold, - Consumer> action) { + Consumer> action) { if (action == null) throw new NullPointerException(); - new ForEachEntryTask(null, batchFor(parallelismThreshold), 0, 0, table, - action).invoke(); + new ForEachEntryTask(null, batchFor(parallelismThreshold), 0, 0, table, + action).invoke(); } /** @@ -4200,22 +4289,22 @@ public class ConcurrentHashMap extends AbstractMap * of each entry. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element, or null if there is no transformation (in - * which case the action is not applied) - * @param action the action - * @param the return type of the transformer + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element, or null if there is no transformation (in + * which case the action is not applied) + * @param action the action + * @param the return type of the transformer * @since 1.8 */ public void forEachEntry(long parallelismThreshold, - Function, ? extends U> transformer, + Function, ? extends U> transformer, Consumer action) { if (transformer == null || action == null) throw new NullPointerException(); - new ForEachTransformedEntryTask - (null, batchFor(parallelismThreshold), 0, 0, table, - transformer, action).invoke(); + new ForEachTransformedEntryTask + (null, batchFor(parallelismThreshold), 0, 0, table, + transformer, action).invoke(); } /** @@ -4226,20 +4315,20 @@ public class ConcurrentHashMap extends AbstractMap * ignored. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param searchFunction a function returning a non-null - * result on success, else null - * @param the return type of the search function + * needed for this operation to be executed in parallel + * @param searchFunction a function returning a non-null + * result on success, else null + * @param the return type of the search function * @return a non-null result from applying the given search * function on each entry, or null if none * @since 1.8 */ public U searchEntries(long parallelismThreshold, - Function, ? extends U> searchFunction) { + Function, ? extends U> searchFunction) { if (searchFunction == null) throw new NullPointerException(); - return new SearchEntriesTask - (null, batchFor(parallelismThreshold), 0, 0, table, - searchFunction, new AtomicReference()).invoke(); + return new SearchEntriesTask + (null, batchFor(parallelismThreshold), 0, 0, table, + searchFunction, new AtomicReference()).invoke(); } /** @@ -4247,17 +4336,17 @@ public class ConcurrentHashMap extends AbstractMap * given reducer to combine values, or null if none. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param reducer a commutative associative combining function * @return the result of accumulating all entries * @since 1.8 */ - public Map.Entry reduceEntries(long parallelismThreshold, - BiFunction, Map.Entry, ? extends Map.Entry> reducer) { + public Map.Entry reduceEntries(long parallelismThreshold, + BiFunction, Map.Entry, ? extends Map.Entry> reducer) { if (reducer == null) throw new NullPointerException(); - return new ReduceEntriesTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, reducer).invoke(); + return new ReduceEntriesTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, reducer).invoke(); } /** @@ -4266,24 +4355,24 @@ public class ConcurrentHashMap extends AbstractMap * or null if none. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element, or null if there is no transformation (in - * which case it is not combined) - * @param reducer a commutative associative combining function - * @param the return type of the transformer + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element, or null if there is no transformation (in + * which case it is not combined) + * @param reducer a commutative associative combining function + * @param the return type of the transformer * @return the result of accumulating the given transformation * of all entries * @since 1.8 */ public U reduceEntries(long parallelismThreshold, - Function, ? extends U> transformer, + Function, ? extends U> transformer, BiFunction reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceEntriesTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, reducer).invoke(); + return new MapReduceEntriesTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, reducer).invoke(); } /** @@ -4292,24 +4381,24 @@ public class ConcurrentHashMap extends AbstractMap * and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all entries * @since 1.8 */ public double reduceEntriesToDouble(long parallelismThreshold, - ToDoubleFunction> transformer, + ToDoubleFunction> transformer, double basis, DoubleBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceEntriesToDoubleTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceEntriesToDoubleTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** @@ -4318,24 +4407,24 @@ public class ConcurrentHashMap extends AbstractMap * and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all entries * @since 1.8 */ public long reduceEntriesToLong(long parallelismThreshold, - ToLongFunction> transformer, + ToLongFunction> transformer, long basis, LongBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceEntriesToLongTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceEntriesToLongTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } /** @@ -4344,24 +4433,24 @@ public class ConcurrentHashMap extends AbstractMap * and the given basis as an identity value. * * @param parallelismThreshold the (estimated) number of elements - * needed for this operation to be executed in parallel - * @param transformer a function returning the transformation - * for an element - * @param basis the identity (initial default value) for the reduction - * @param reducer a commutative associative combining function + * needed for this operation to be executed in parallel + * @param transformer a function returning the transformation + * for an element + * @param basis the identity (initial default value) for the reduction + * @param reducer a commutative associative combining function * @return the result of accumulating the given transformation * of all entries * @since 1.8 */ public int reduceEntriesToInt(long parallelismThreshold, - ToIntFunction> transformer, + ToIntFunction> transformer, int basis, IntBinaryOperator reducer) { if (transformer == null || reducer == null) throw new NullPointerException(); - return new MapReduceEntriesToIntTask - (null, batchFor(parallelismThreshold), 0, 0, table, - null, transformer, basis, reducer).invoke(); + return new MapReduceEntriesToIntTask + (null, batchFor(parallelismThreshold), 0, 0, table, + null, transformer, basis, reducer).invoke(); } @@ -4370,29 +4459,43 @@ public class ConcurrentHashMap extends AbstractMap /** * Base class for views. */ - abstract static class CollectionView - implements Collection, java.io.Serializable { + abstract static class CollectionView + implements Collection, java.io.Serializable { private static final long serialVersionUID = 7249069246763182397L; - final ConcurrentHashMap map; - CollectionView(ConcurrentHashMap map) { this.map = map; } + final ConcurrentHashMap map; + + CollectionView(ConcurrentHashMap map) { + this.map = map; + } /** * Returns the map backing this view. * * @return the map backing this view */ - public ConcurrentHashMap getMap() { return map; } + public ConcurrentHashMap getMap() { + return map; + } /** * Removes all of the elements from this view, by removing all * the mappings from the map backing this view. */ - public final void clear() { map.clear(); } - public final int size() { return map.size(); } - public final boolean isEmpty() { return map.isEmpty(); } + public final void clear() { + map.clear(); + } + + public final int size() { + return map.size(); + } + + public final boolean isEmpty() { + return map.isEmpty(); + } // implementations below rely on concrete classes supplying these // abstract methods + /** * Returns an iterator over the elements in this collection. * @@ -4402,7 +4505,9 @@ public class ConcurrentHashMap extends AbstractMap * @return an iterator over the elements in this collection */ public abstract Iterator iterator(); + public abstract boolean contains(Object o); + public abstract boolean remove(Object o); private static final String oomeMsg = "Required array size too large"; @@ -4411,7 +4516,7 @@ public class ConcurrentHashMap extends AbstractMap long sz = map.mappingCount(); if (sz > MAX_ARRAY_SIZE) throw new OutOfMemoryError(oomeMsg); - int n = (int)sz; + int n = (int) sz; Object[] r = new Object[n]; int i = 0; for (E e : this) { @@ -4434,10 +4539,10 @@ public class ConcurrentHashMap extends AbstractMap long sz = map.mappingCount(); if (sz > MAX_ARRAY_SIZE) throw new OutOfMemoryError(oomeMsg); - int m = (int)sz; + int m = (int) sz; T[] r = (a.length >= m) ? a : - (T[])java.lang.reflect.Array - .newInstance(a.getClass().getComponentType(), m); + (T[]) java.lang.reflect.Array + .newInstance(a.getClass().getComponentType(), m); int n = r.length; int i = 0; for (E e : this) { @@ -4450,7 +4555,7 @@ public class ConcurrentHashMap extends AbstractMap n += (n >>> 1) + 1; r = Arrays.copyOf(r, n); } - r[i++] = (T)e; + r[i++] = (T) e; } if (a == r && i < n) { r[i] = null; // null-terminate @@ -4475,7 +4580,7 @@ public class ConcurrentHashMap extends AbstractMap sb.append('['); Iterator it = iterator(); if (it.hasNext()) { - for (;;) { + for (; ; ) { Object e = it.next(); sb.append(e == this ? "(this Collection)" : e); if (!it.hasNext()) @@ -4499,7 +4604,7 @@ public class ConcurrentHashMap extends AbstractMap public final boolean removeAll(Collection c) { if (c == null) throw new NullPointerException(); boolean modified = false; - for (Iterator it = iterator(); it.hasNext();) { + for (Iterator it = iterator(); it.hasNext(); ) { if (c.contains(it.next())) { it.remove(); modified = true; @@ -4511,7 +4616,7 @@ public class ConcurrentHashMap extends AbstractMap public final boolean retainAll(Collection c) { if (c == null) throw new NullPointerException(); boolean modified = false; - for (Iterator it = iterator(); it.hasNext();) { + for (Iterator it = iterator(); it.hasNext(); ) { if (!c.contains(it.next())) { it.remove(); modified = true; @@ -4533,11 +4638,12 @@ public class ConcurrentHashMap extends AbstractMap * * @since 1.8 */ - public static class KeySetView extends CollectionView - implements Set, java.io.Serializable { + public static class KeySetView extends CollectionView + implements Set, java.io.Serializable { private static final long serialVersionUID = 7249069246763182397L; private final V value; - KeySetView(ConcurrentHashMap map, V value) { // non-public + + KeySetView(ConcurrentHashMap map, V value) { // non-public super(map); this.value = value; } @@ -4549,33 +4655,40 @@ public class ConcurrentHashMap extends AbstractMap * @return the default mapped value for additions, or {@code null} * if not supported */ - public V getMappedValue() { return value; } + public V getMappedValue() { + return value; + } /** * {@inheritDoc} + * * @throws NullPointerException if the specified key is null */ - public boolean contains(Object o) { return map.containsKey(o); } + public boolean contains(Object o) { + return map.containsKey(o); + } /** * Removes the key from this map view, by removing the key (and its * corresponding value) from the backing map. This method does * nothing if the key is not in the map. * - * @param o the key to be removed from the backing map + * @param o the key to be removed from the backing map * @return {@code true} if the backing map contained the specified key * @throws NullPointerException if the specified key is null */ - public boolean remove(Object o) { return map.remove(o) != null; } + public boolean remove(Object o) { + return map.remove(o) != null; + } /** * @return an iterator over the keys of the backing map */ public Iterator iterator() { - Node[] t; - ConcurrentHashMap m = map; + Node[] t; + ConcurrentHashMap m = map; int f = (t = m.table) == null ? 0 : t.length; - return new KeyIterator(t, f, 0, f, m); + return new KeyIterator(t, f, 0, f, m); } /** @@ -4584,9 +4697,9 @@ public class ConcurrentHashMap extends AbstractMap * * @param e key to be added * @return {@code true} if this set changed as a result of the call - * @throws NullPointerException if the specified key is null + * @throws NullPointerException if the specified key is null * @throws UnsupportedOperationException if no default mapped value - * for additions was provided + * for additions was provided */ public boolean add(K e) { V v; @@ -4601,10 +4714,10 @@ public class ConcurrentHashMap extends AbstractMap * * @param c the elements to be inserted into this set * @return {@code true} if this set changed as a result of the call - * @throws NullPointerException if the collection or any of its - * elements are {@code null} + * @throws NullPointerException if the collection or any of its + * elements are {@code null} * @throws UnsupportedOperationException if no default mapped value - * for additions was provided + * for additions was provided */ public boolean addAll(Collection c) { boolean added = false; @@ -4628,24 +4741,24 @@ public class ConcurrentHashMap extends AbstractMap public boolean equals(Object o) { Set c; return ((o instanceof Set) && - ((c = (Set)o) == this || - (containsAll(c) && c.containsAll(this)))); + ((c = (Set) o) == this || + (containsAll(c) && c.containsAll(this)))); } public Spliterator spliterator() { - Node[] t; - ConcurrentHashMap m = map; + Node[] t; + ConcurrentHashMap m = map; long n = m.sumCount(); int f = (t = m.table) == null ? 0 : t.length; - return new KeySpliterator(t, f, 0, f, n < 0L ? 0L : n); + return new KeySpliterator(t, f, 0, f, n < 0L ? 0L : n); } public void forEach(Consumer action) { if (action == null) throw new NullPointerException(); - Node[] t; + Node[] t; if ((t = map.table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) action.accept(p.key); } } @@ -4656,17 +4769,21 @@ public class ConcurrentHashMap extends AbstractMap * values, in which additions are disabled. This class cannot be * directly instantiated. See {@link #values()}. */ - static final class ValuesView extends CollectionView - implements Collection, java.io.Serializable { + static final class ValuesView extends CollectionView + implements Collection, java.io.Serializable { private static final long serialVersionUID = 2249069246763182397L; - ValuesView(ConcurrentHashMap map) { super(map); } + + ValuesView(ConcurrentHashMap map) { + super(map); + } + public final boolean contains(Object o) { return map.containsValue(o); } public final boolean remove(Object o) { if (o != null) { - for (Iterator it = iterator(); it.hasNext();) { + for (Iterator it = iterator(); it.hasNext(); ) { if (o.equals(it.next())) { it.remove(); return true; @@ -4677,33 +4794,34 @@ public class ConcurrentHashMap extends AbstractMap } public final Iterator iterator() { - ConcurrentHashMap m = map; - Node[] t; + ConcurrentHashMap m = map; + Node[] t; int f = (t = m.table) == null ? 0 : t.length; - return new ValueIterator(t, f, 0, f, m); + return new ValueIterator(t, f, 0, f, m); } public final boolean add(V e) { throw new UnsupportedOperationException(); } + public final boolean addAll(Collection c) { throw new UnsupportedOperationException(); } public Spliterator spliterator() { - Node[] t; - ConcurrentHashMap m = map; + Node[] t; + ConcurrentHashMap m = map; long n = m.sumCount(); int f = (t = m.table) == null ? 0 : t.length; - return new ValueSpliterator(t, f, 0, f, n < 0L ? 0L : n); + return new ValueSpliterator(t, f, 0, f, n < 0L ? 0L : n); } public void forEach(Consumer action) { if (action == null) throw new NullPointerException(); - Node[] t; + Node[] t; if ((t = map.table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) action.accept(p.val); } } @@ -4714,24 +4832,29 @@ public class ConcurrentHashMap extends AbstractMap * entries. This class cannot be directly instantiated. See * {@link #entrySet()}. */ - static final class EntrySetView extends CollectionView> - implements Set>, java.io.Serializable { + static final class EntrySetView extends CollectionView> + implements Set>, java.io.Serializable { private static final long serialVersionUID = 2249069246763182397L; - EntrySetView(ConcurrentHashMap map) { super(map); } + + EntrySetView(ConcurrentHashMap map) { + super(map); + } public boolean contains(Object o) { - Object k, v, r; Map.Entry e; + Object k, v, r; + Map.Entry e; return ((o instanceof Map.Entry) && - (k = (e = (Map.Entry)o).getKey()) != null && + (k = (e = (Map.Entry) o).getKey()) != null && (r = map.get(k)) != null && (v = e.getValue()) != null && (v == r || v.equals(r))); } public boolean remove(Object o) { - Object k, v; Map.Entry e; + Object k, v; + Map.Entry e; return ((o instanceof Map.Entry) && - (k = (e = (Map.Entry)o).getKey()) != null && + (k = (e = (Map.Entry) o).getKey()) != null && (v = e.getValue()) != null && map.remove(k, v)); } @@ -4739,20 +4862,20 @@ public class ConcurrentHashMap extends AbstractMap /** * @return an iterator over the entries of the backing map */ - public Iterator> iterator() { - ConcurrentHashMap m = map; - Node[] t; + public Iterator> iterator() { + ConcurrentHashMap m = map; + Node[] t; int f = (t = m.table) == null ? 0 : t.length; - return new EntryIterator(t, f, 0, f, m); + return new EntryIterator(t, f, 0, f, m); } - public boolean add(Entry e) { + public boolean add(Entry e) { return map.putVal(e.getKey(), e.getValue(), false) == null; } - public boolean addAll(Collection> c) { + public boolean addAll(Collection> c) { boolean added = false; - for (Entry e : c) { + for (Entry e : c) { if (add(e)) added = true; } @@ -4761,10 +4884,10 @@ public class ConcurrentHashMap extends AbstractMap public final int hashCode() { int h = 0; - Node[] t; + Node[] t; if ((t = map.table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) { + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) { h += p.hashCode(); } } @@ -4774,25 +4897,25 @@ public class ConcurrentHashMap extends AbstractMap public final boolean equals(Object o) { Set c; return ((o instanceof Set) && - ((c = (Set)o) == this || - (containsAll(c) && c.containsAll(this)))); + ((c = (Set) o) == this || + (containsAll(c) && c.containsAll(this)))); } - public Spliterator> spliterator() { - Node[] t; - ConcurrentHashMap m = map; + public Spliterator> spliterator() { + Node[] t; + ConcurrentHashMap m = map; long n = m.sumCount(); int f = (t = m.table) == null ? 0 : t.length; - return new EntrySpliterator(t, f, 0, f, n < 0L ? 0L : n, m); + return new EntrySpliterator(t, f, 0, f, n < 0L ? 0L : n, m); } - public void forEach(Consumer> action) { + public void forEach(Consumer> action) { if (action == null) throw new NullPointerException(); - Node[] t; + Node[] t; if ((t = map.table) != null) { - Traverser it = new Traverser(t, t.length, 0, t.length); - for (Node p; (p = it.advance()) != null; ) - action.accept(new MapEntry(p.key, p.val, map)); + Traverser it = new Traverser(t, t.length, 0, t.length); + for (Node p; (p = it.advance()) != null; ) + action.accept(new MapEntry(p.key, p.val, map)); } } @@ -4805,17 +4928,17 @@ public class ConcurrentHashMap extends AbstractMap * class Traverser, because we need to subclass CountedCompleter. */ @SuppressWarnings("serial") - abstract static class BulkTask extends CountedCompleter { - Node[] tab; // same as Traverser - Node next; - TableStack stack, spare; + abstract static class BulkTask extends CountedCompleter { + Node[] tab; // same as Traverser + Node next; + TableStack stack, spare; int index; int baseIndex; int baseLimit; final int baseSize; int batch; // split control - BulkTask(BulkTask par, int b, int i, int f, Node[] t) { + BulkTask(BulkTask par, int b, int i, int f, Node[] t) { super(par); this.batch = b; this.index = this.baseIndex = i; @@ -4832,26 +4955,26 @@ public class ConcurrentHashMap extends AbstractMap /** * Same as Traverser version */ - final Node advance() { - Node e; + final Node advance() { + Node e; if ((e = next) != null) e = e.next; - for (;;) { - Node[] t; int i, n; + for (; ; ) { + Node[] t; + int i, n; if (e != null) return next = e; if (baseIndex >= baseLimit || (t = tab) == null || - (n = t.length) <= (i = index) || i < 0) + (n = t.length) <= (i = index) || i < 0) return next = null; if ((e = tabAt(t, i)) != null && e.hash < 0) { if (e instanceof ForwardingNode) { - tab = ((ForwardingNode)e).nextTable; + tab = ((ForwardingNode) e).nextTable; e = null; pushState(t, i, n); continue; - } - else if (e instanceof TreeBin) - e = ((TreeBin)e).first; + } else if (e instanceof TreeBin) + e = ((TreeBin) e).first; else e = null; } @@ -4862,12 +4985,12 @@ public class ConcurrentHashMap extends AbstractMap } } - private void pushState(Node[] t, int i, int n) { - TableStack s = spare; + private void pushState(Node[] t, int i, int n) { + TableStack s = spare; if (s != null) spare = s.next; else - s = new TableStack(); + s = new TableStack(); s.tab = t; s.length = n; s.index = i; @@ -4876,13 +4999,14 @@ public class ConcurrentHashMap extends AbstractMap } private void recoverState(int n) { - TableStack s; int len; + TableStack s; + int len; while ((s = stack) != null && (index += (len = s.length)) >= n) { n = len; index = s.index; tab = s.tab; s.tab = null; - TableStack next = s.next; + TableStack next = s.next; s.next = spare; // save for reuse stack = next; spare = s; @@ -4900,26 +5024,28 @@ public class ConcurrentHashMap extends AbstractMap * simplest hoisted bypass to help avoid convoluted traps. */ @SuppressWarnings("serial") - static final class ForEachKeyTask - extends BulkTask { + static final class ForEachKeyTask + extends BulkTask { final Consumer action; + ForEachKeyTask - (BulkTask p, int b, int i, int f, Node[] t, - Consumer action) { + (BulkTask p, int b, int i, int f, Node[] t, + Consumer action) { super(p, b, i, f, t); this.action = action; } + public final void compute() { final Consumer action; if ((action = this.action) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - new ForEachKeyTask - (this, batch >>>= 1, baseLimit = h, f, tab, - action).fork(); + new ForEachKeyTask + (this, batch >>>= 1, baseLimit = h, f, tab, + action).fork(); } - for (Node p; (p = advance()) != null;) + for (Node p; (p = advance()) != null; ) action.accept(p.key); propagateCompletion(); } @@ -4927,26 +5053,28 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ForEachValueTask - extends BulkTask { + static final class ForEachValueTask + extends BulkTask { final Consumer action; + ForEachValueTask - (BulkTask p, int b, int i, int f, Node[] t, - Consumer action) { + (BulkTask p, int b, int i, int f, Node[] t, + Consumer action) { super(p, b, i, f, t); this.action = action; } + public final void compute() { final Consumer action; if ((action = this.action) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - new ForEachValueTask - (this, batch >>>= 1, baseLimit = h, f, tab, - action).fork(); + new ForEachValueTask + (this, batch >>>= 1, baseLimit = h, f, tab, + action).fork(); } - for (Node p; (p = advance()) != null;) + for (Node p; (p = advance()) != null; ) action.accept(p.val); propagateCompletion(); } @@ -4954,26 +5082,28 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ForEachEntryTask - extends BulkTask { - final Consumer> action; + static final class ForEachEntryTask + extends BulkTask { + final Consumer> action; + ForEachEntryTask - (BulkTask p, int b, int i, int f, Node[] t, - Consumer> action) { + (BulkTask p, int b, int i, int f, Node[] t, + Consumer> action) { super(p, b, i, f, t); this.action = action; } + public final void compute() { - final Consumer> action; + final Consumer> action; if ((action = this.action) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - new ForEachEntryTask - (this, batch >>>= 1, baseLimit = h, f, tab, - action).fork(); + new ForEachEntryTask + (this, batch >>>= 1, baseLimit = h, f, tab, + action).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) action.accept(p); propagateCompletion(); } @@ -4981,26 +5111,28 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ForEachMappingTask - extends BulkTask { + static final class ForEachMappingTask + extends BulkTask { final BiConsumer action; + ForEachMappingTask - (BulkTask p, int b, int i, int f, Node[] t, - BiConsumer action) { + (BulkTask p, int b, int i, int f, Node[] t, + BiConsumer action) { super(p, b, i, f, t); this.action = action; } + public final void compute() { final BiConsumer action; if ((action = this.action) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - new ForEachMappingTask - (this, batch >>>= 1, baseLimit = h, f, tab, - action).fork(); + new ForEachMappingTask + (this, batch >>>= 1, baseLimit = h, f, tab, + action).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) action.accept(p.key, p.val); propagateCompletion(); } @@ -5008,29 +5140,32 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ForEachTransformedKeyTask - extends BulkTask { + static final class ForEachTransformedKeyTask + extends BulkTask { final Function transformer; final Consumer action; + ForEachTransformedKeyTask - (BulkTask p, int b, int i, int f, Node[] t, - Function transformer, Consumer action) { + (BulkTask p, int b, int i, int f, Node[] t, + Function transformer, Consumer action) { super(p, b, i, f, t); - this.transformer = transformer; this.action = action; + this.transformer = transformer; + this.action = action; } + public final void compute() { final Function transformer; final Consumer action; if ((transformer = this.transformer) != null && - (action = this.action) != null) { + (action = this.action) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - new ForEachTransformedKeyTask - (this, batch >>>= 1, baseLimit = h, f, tab, - transformer, action).fork(); + new ForEachTransformedKeyTask + (this, batch >>>= 1, baseLimit = h, f, tab, + transformer, action).fork(); } - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { U u; if ((u = transformer.apply(p.key)) != null) action.accept(u); @@ -5041,29 +5176,32 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ForEachTransformedValueTask - extends BulkTask { + static final class ForEachTransformedValueTask + extends BulkTask { final Function transformer; final Consumer action; + ForEachTransformedValueTask - (BulkTask p, int b, int i, int f, Node[] t, - Function transformer, Consumer action) { + (BulkTask p, int b, int i, int f, Node[] t, + Function transformer, Consumer action) { super(p, b, i, f, t); - this.transformer = transformer; this.action = action; + this.transformer = transformer; + this.action = action; } + public final void compute() { final Function transformer; final Consumer action; if ((transformer = this.transformer) != null && - (action = this.action) != null) { + (action = this.action) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - new ForEachTransformedValueTask - (this, batch >>>= 1, baseLimit = h, f, tab, - transformer, action).fork(); + new ForEachTransformedValueTask + (this, batch >>>= 1, baseLimit = h, f, tab, + transformer, action).fork(); } - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { U u; if ((u = transformer.apply(p.val)) != null) action.accept(u); @@ -5074,29 +5212,32 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ForEachTransformedEntryTask - extends BulkTask { - final Function, ? extends U> transformer; + static final class ForEachTransformedEntryTask + extends BulkTask { + final Function, ? extends U> transformer; final Consumer action; + ForEachTransformedEntryTask - (BulkTask p, int b, int i, int f, Node[] t, - Function, ? extends U> transformer, Consumer action) { + (BulkTask p, int b, int i, int f, Node[] t, + Function, ? extends U> transformer, Consumer action) { super(p, b, i, f, t); - this.transformer = transformer; this.action = action; + this.transformer = transformer; + this.action = action; } + public final void compute() { - final Function, ? extends U> transformer; + final Function, ? extends U> transformer; final Consumer action; if ((transformer = this.transformer) != null && - (action = this.action) != null) { + (action = this.action) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - new ForEachTransformedEntryTask - (this, batch >>>= 1, baseLimit = h, f, tab, - transformer, action).fork(); + new ForEachTransformedEntryTask + (this, batch >>>= 1, baseLimit = h, f, tab, + transformer, action).fork(); } - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { U u; if ((u = transformer.apply(p)) != null) action.accept(u); @@ -5107,30 +5248,33 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ForEachTransformedMappingTask - extends BulkTask { + static final class ForEachTransformedMappingTask + extends BulkTask { final BiFunction transformer; final Consumer action; + ForEachTransformedMappingTask - (BulkTask p, int b, int i, int f, Node[] t, - BiFunction transformer, - Consumer action) { + (BulkTask p, int b, int i, int f, Node[] t, + BiFunction transformer, + Consumer action) { super(p, b, i, f, t); - this.transformer = transformer; this.action = action; + this.transformer = transformer; + this.action = action; } + public final void compute() { final BiFunction transformer; final Consumer action; if ((transformer = this.transformer) != null && - (action = this.action) != null) { + (action = this.action) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - new ForEachTransformedMappingTask - (this, batch >>>= 1, baseLimit = h, f, tab, - transformer, action).fork(); + new ForEachTransformedMappingTask + (this, batch >>>= 1, baseLimit = h, f, tab, + transformer, action).fork(); } - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { U u; if ((u = transformer.apply(p.key, p.val)) != null) action.accept(u); @@ -5141,35 +5285,41 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class SearchKeysTask - extends BulkTask { + static final class SearchKeysTask + extends BulkTask { final Function searchFunction; final AtomicReference result; + SearchKeysTask - (BulkTask p, int b, int i, int f, Node[] t, - Function searchFunction, - AtomicReference result) { + (BulkTask p, int b, int i, int f, Node[] t, + Function searchFunction, + AtomicReference result) { super(p, b, i, f, t); - this.searchFunction = searchFunction; this.result = result; + this.searchFunction = searchFunction; + this.result = result; } - public final U getRawResult() { return result.get(); } + + public final U getRawResult() { + return result.get(); + } + public final void compute() { final Function searchFunction; final AtomicReference result; if ((searchFunction = this.searchFunction) != null && - (result = this.result) != null) { + (result = this.result) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { if (result.get() != null) return; addToPendingCount(1); - new SearchKeysTask - (this, batch >>>= 1, baseLimit = h, f, tab, - searchFunction, result).fork(); + new SearchKeysTask + (this, batch >>>= 1, baseLimit = h, f, tab, + searchFunction, result).fork(); } while (result.get() == null) { U u; - Node p; + Node p; if ((p = advance()) == null) { propagateCompletion(); break; @@ -5185,35 +5335,41 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class SearchValuesTask - extends BulkTask { + static final class SearchValuesTask + extends BulkTask { final Function searchFunction; final AtomicReference result; + SearchValuesTask - (BulkTask p, int b, int i, int f, Node[] t, - Function searchFunction, - AtomicReference result) { + (BulkTask p, int b, int i, int f, Node[] t, + Function searchFunction, + AtomicReference result) { super(p, b, i, f, t); - this.searchFunction = searchFunction; this.result = result; + this.searchFunction = searchFunction; + this.result = result; + } + + public final U getRawResult() { + return result.get(); } - public final U getRawResult() { return result.get(); } + public final void compute() { final Function searchFunction; final AtomicReference result; if ((searchFunction = this.searchFunction) != null && - (result = this.result) != null) { + (result = this.result) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { if (result.get() != null) return; addToPendingCount(1); - new SearchValuesTask - (this, batch >>>= 1, baseLimit = h, f, tab, - searchFunction, result).fork(); + new SearchValuesTask + (this, batch >>>= 1, baseLimit = h, f, tab, + searchFunction, result).fork(); } while (result.get() == null) { U u; - Node p; + Node p; if ((p = advance()) == null) { propagateCompletion(); break; @@ -5229,35 +5385,41 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class SearchEntriesTask - extends BulkTask { - final Function, ? extends U> searchFunction; + static final class SearchEntriesTask + extends BulkTask { + final Function, ? extends U> searchFunction; final AtomicReference result; + SearchEntriesTask - (BulkTask p, int b, int i, int f, Node[] t, - Function, ? extends U> searchFunction, - AtomicReference result) { + (BulkTask p, int b, int i, int f, Node[] t, + Function, ? extends U> searchFunction, + AtomicReference result) { super(p, b, i, f, t); - this.searchFunction = searchFunction; this.result = result; + this.searchFunction = searchFunction; + this.result = result; + } + + public final U getRawResult() { + return result.get(); } - public final U getRawResult() { return result.get(); } + public final void compute() { - final Function, ? extends U> searchFunction; + final Function, ? extends U> searchFunction; final AtomicReference result; if ((searchFunction = this.searchFunction) != null && - (result = this.result) != null) { + (result = this.result) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { if (result.get() != null) return; addToPendingCount(1); - new SearchEntriesTask - (this, batch >>>= 1, baseLimit = h, f, tab, - searchFunction, result).fork(); + new SearchEntriesTask + (this, batch >>>= 1, baseLimit = h, f, tab, + searchFunction, result).fork(); } while (result.get() == null) { U u; - Node p; + Node p; if ((p = advance()) == null) { propagateCompletion(); break; @@ -5273,35 +5435,41 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class SearchMappingsTask - extends BulkTask { + static final class SearchMappingsTask + extends BulkTask { final BiFunction searchFunction; final AtomicReference result; + SearchMappingsTask - (BulkTask p, int b, int i, int f, Node[] t, - BiFunction searchFunction, - AtomicReference result) { + (BulkTask p, int b, int i, int f, Node[] t, + BiFunction searchFunction, + AtomicReference result) { super(p, b, i, f, t); - this.searchFunction = searchFunction; this.result = result; + this.searchFunction = searchFunction; + this.result = result; } - public final U getRawResult() { return result.get(); } + + public final U getRawResult() { + return result.get(); + } + public final void compute() { final BiFunction searchFunction; final AtomicReference result; if ((searchFunction = this.searchFunction) != null && - (result = this.result) != null) { + (result = this.result) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { if (result.get() != null) return; addToPendingCount(1); - new SearchMappingsTask - (this, batch >>>= 1, baseLimit = h, f, tab, - searchFunction, result).fork(); + new SearchMappingsTask + (this, batch >>>= 1, baseLimit = h, f, tab, + searchFunction, result).fork(); } while (result.get() == null) { U u; - Node p; + Node p; if ((p = advance()) == null) { propagateCompletion(); break; @@ -5317,31 +5485,37 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ReduceKeysTask - extends BulkTask { + static final class ReduceKeysTask + extends BulkTask { final BiFunction reducer; K result; - ReduceKeysTask rights, nextRight; + ReduceKeysTask rights, nextRight; + ReduceKeysTask - (BulkTask p, int b, int i, int f, Node[] t, - ReduceKeysTask nextRight, - BiFunction reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + ReduceKeysTask nextRight, + BiFunction reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.reducer = reducer; } - public final K getRawResult() { return result; } + + public final K getRawResult() { + return result; + } + public final void compute() { final BiFunction reducer; if ((reducer = this.reducer) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new ReduceKeysTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, reducer)).fork(); + (rights = new ReduceKeysTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, reducer)).fork(); } K r = null; - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { K u = p.key; r = (r == null) ? u : u == null ? r : reducer.apply(r, u); } @@ -5349,14 +5523,14 @@ public class ConcurrentHashMap extends AbstractMap CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - ReduceKeysTask - t = (ReduceKeysTask)c, - s = t.rights; + ReduceKeysTask + t = (ReduceKeysTask) c, + s = t.rights; while (s != null) { K tr, sr; if ((sr = s.result) != null) t.result = (((tr = t.result) == null) ? sr : - reducer.apply(tr, sr)); + reducer.apply(tr, sr)); s = t.rights = s.nextRight; } } @@ -5365,31 +5539,37 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ReduceValuesTask - extends BulkTask { + static final class ReduceValuesTask + extends BulkTask { final BiFunction reducer; V result; - ReduceValuesTask rights, nextRight; + ReduceValuesTask rights, nextRight; + ReduceValuesTask - (BulkTask p, int b, int i, int f, Node[] t, - ReduceValuesTask nextRight, - BiFunction reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + ReduceValuesTask nextRight, + BiFunction reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.reducer = reducer; } - public final V getRawResult() { return result; } + + public final V getRawResult() { + return result; + } + public final void compute() { final BiFunction reducer; if ((reducer = this.reducer) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new ReduceValuesTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, reducer)).fork(); + (rights = new ReduceValuesTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, reducer)).fork(); } V r = null; - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { V v = p.val; r = (r == null) ? v : reducer.apply(r, v); } @@ -5397,14 +5577,14 @@ public class ConcurrentHashMap extends AbstractMap CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - ReduceValuesTask - t = (ReduceValuesTask)c, - s = t.rights; + ReduceValuesTask + t = (ReduceValuesTask) c, + s = t.rights; while (s != null) { V tr, sr; if ((sr = s.result) != null) t.result = (((tr = t.result) == null) ? sr : - reducer.apply(tr, sr)); + reducer.apply(tr, sr)); s = t.rights = s.nextRight; } } @@ -5413,44 +5593,50 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class ReduceEntriesTask - extends BulkTask> { - final BiFunction, Map.Entry, ? extends Map.Entry> reducer; - Map.Entry result; - ReduceEntriesTask rights, nextRight; + static final class ReduceEntriesTask + extends BulkTask> { + final BiFunction, Map.Entry, ? extends Map.Entry> reducer; + Map.Entry result; + ReduceEntriesTask rights, nextRight; + ReduceEntriesTask - (BulkTask p, int b, int i, int f, Node[] t, - ReduceEntriesTask nextRight, - BiFunction, Map.Entry, ? extends Map.Entry> reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + ReduceEntriesTask nextRight, + BiFunction, Map.Entry, ? extends Map.Entry> reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.reducer = reducer; } - public final Map.Entry getRawResult() { return result; } + + public final Map.Entry getRawResult() { + return result; + } + public final void compute() { - final BiFunction, Map.Entry, ? extends Map.Entry> reducer; + final BiFunction, Map.Entry, ? extends Map.Entry> reducer; if ((reducer = this.reducer) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new ReduceEntriesTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, reducer)).fork(); + (rights = new ReduceEntriesTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, reducer)).fork(); } - Map.Entry r = null; - for (Node p; (p = advance()) != null; ) + Map.Entry r = null; + for (Node p; (p = advance()) != null; ) r = (r == null) ? p : reducer.apply(r, p); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - ReduceEntriesTask - t = (ReduceEntriesTask)c, - s = t.rights; + ReduceEntriesTask + t = (ReduceEntriesTask) c, + s = t.rights; while (s != null) { - Map.Entry tr, sr; + Map.Entry tr, sr; if ((sr = s.result) != null) t.result = (((tr = t.result) == null) ? sr : - reducer.apply(tr, sr)); + reducer.apply(tr, sr)); s = t.rights = s.nextRight; } } @@ -5459,36 +5645,42 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceKeysTask - extends BulkTask { + static final class MapReduceKeysTask + extends BulkTask { final Function transformer; final BiFunction reducer; U result; - MapReduceKeysTask rights, nextRight; + MapReduceKeysTask rights, nextRight; + MapReduceKeysTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceKeysTask nextRight, - Function transformer, - BiFunction reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceKeysTask nextRight, + Function transformer, + BiFunction reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; this.reducer = reducer; } - public final U getRawResult() { return result; } + + public final U getRawResult() { + return result; + } + public final void compute() { final Function transformer; final BiFunction reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceKeysTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, reducer)).fork(); + (rights = new MapReduceKeysTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, reducer)).fork(); } U r = null; - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { U u; if ((u = transformer.apply(p.key)) != null) r = (r == null) ? u : reducer.apply(r, u); @@ -5497,14 +5689,14 @@ public class ConcurrentHashMap extends AbstractMap CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceKeysTask - t = (MapReduceKeysTask)c, - s = t.rights; + MapReduceKeysTask + t = (MapReduceKeysTask) c, + s = t.rights; while (s != null) { U tr, sr; if ((sr = s.result) != null) t.result = (((tr = t.result) == null) ? sr : - reducer.apply(tr, sr)); + reducer.apply(tr, sr)); s = t.rights = s.nextRight; } } @@ -5513,36 +5705,42 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceValuesTask - extends BulkTask { + static final class MapReduceValuesTask + extends BulkTask { final Function transformer; final BiFunction reducer; U result; - MapReduceValuesTask rights, nextRight; + MapReduceValuesTask rights, nextRight; + MapReduceValuesTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceValuesTask nextRight, - Function transformer, - BiFunction reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceValuesTask nextRight, + Function transformer, + BiFunction reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; this.reducer = reducer; } - public final U getRawResult() { return result; } + + public final U getRawResult() { + return result; + } + public final void compute() { final Function transformer; final BiFunction reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceValuesTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, reducer)).fork(); + (rights = new MapReduceValuesTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, reducer)).fork(); } U r = null; - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { U u; if ((u = transformer.apply(p.val)) != null) r = (r == null) ? u : reducer.apply(r, u); @@ -5551,14 +5749,14 @@ public class ConcurrentHashMap extends AbstractMap CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceValuesTask - t = (MapReduceValuesTask)c, - s = t.rights; + MapReduceValuesTask + t = (MapReduceValuesTask) c, + s = t.rights; while (s != null) { U tr, sr; if ((sr = s.result) != null) t.result = (((tr = t.result) == null) ? sr : - reducer.apply(tr, sr)); + reducer.apply(tr, sr)); s = t.rights = s.nextRight; } } @@ -5567,36 +5765,42 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceEntriesTask - extends BulkTask { - final Function, ? extends U> transformer; + static final class MapReduceEntriesTask + extends BulkTask { + final Function, ? extends U> transformer; final BiFunction reducer; U result; - MapReduceEntriesTask rights, nextRight; + MapReduceEntriesTask rights, nextRight; + MapReduceEntriesTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceEntriesTask nextRight, - Function, ? extends U> transformer, - BiFunction reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceEntriesTask nextRight, + Function, ? extends U> transformer, + BiFunction reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; this.reducer = reducer; } - public final U getRawResult() { return result; } + + public final U getRawResult() { + return result; + } + public final void compute() { - final Function, ? extends U> transformer; + final Function, ? extends U> transformer; final BiFunction reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceEntriesTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, reducer)).fork(); + (rights = new MapReduceEntriesTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, reducer)).fork(); } U r = null; - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { U u; if ((u = transformer.apply(p)) != null) r = (r == null) ? u : reducer.apply(r, u); @@ -5605,14 +5809,14 @@ public class ConcurrentHashMap extends AbstractMap CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceEntriesTask - t = (MapReduceEntriesTask)c, - s = t.rights; + MapReduceEntriesTask + t = (MapReduceEntriesTask) c, + s = t.rights; while (s != null) { U tr, sr; if ((sr = s.result) != null) t.result = (((tr = t.result) == null) ? sr : - reducer.apply(tr, sr)); + reducer.apply(tr, sr)); s = t.rights = s.nextRight; } } @@ -5621,36 +5825,42 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceMappingsTask - extends BulkTask { + static final class MapReduceMappingsTask + extends BulkTask { final BiFunction transformer; final BiFunction reducer; U result; - MapReduceMappingsTask rights, nextRight; + MapReduceMappingsTask rights, nextRight; + MapReduceMappingsTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceMappingsTask nextRight, - BiFunction transformer, - BiFunction reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceMappingsTask nextRight, + BiFunction transformer, + BiFunction reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; this.reducer = reducer; } - public final U getRawResult() { return result; } + + public final U getRawResult() { + return result; + } + public final void compute() { final BiFunction transformer; final BiFunction reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceMappingsTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, reducer)).fork(); + (rights = new MapReduceMappingsTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, reducer)).fork(); } U r = null; - for (Node p; (p = advance()) != null; ) { + for (Node p; (p = advance()) != null; ) { U u; if ((u = transformer.apply(p.key, p.val)) != null) r = (r == null) ? u : reducer.apply(r, u); @@ -5659,14 +5869,14 @@ public class ConcurrentHashMap extends AbstractMap CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceMappingsTask - t = (MapReduceMappingsTask)c, - s = t.rights; + MapReduceMappingsTask + t = (MapReduceMappingsTask) c, + s = t.rights; while (s != null) { U tr, sr; if ((sr = s.result) != null) t.result = (((tr = t.result) == null) ? sr : - reducer.apply(tr, sr)); + reducer.apply(tr, sr)); s = t.rights = s.nextRight; } } @@ -5675,46 +5885,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceKeysToDoubleTask - extends BulkTask { + static final class MapReduceKeysToDoubleTask + extends BulkTask { final ToDoubleFunction transformer; final DoubleBinaryOperator reducer; final double basis; double result; - MapReduceKeysToDoubleTask rights, nextRight; + MapReduceKeysToDoubleTask rights, nextRight; + MapReduceKeysToDoubleTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceKeysToDoubleTask nextRight, - ToDoubleFunction transformer, - double basis, - DoubleBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceKeysToDoubleTask nextRight, + ToDoubleFunction transformer, + double basis, + DoubleBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; + } + + public final Double getRawResult() { + return result; } - public final Double getRawResult() { return result; } + public final void compute() { final ToDoubleFunction transformer; final DoubleBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { double r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceKeysToDoubleTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceKeysToDoubleTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.key)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceKeysToDoubleTask - t = (MapReduceKeysToDoubleTask)c, - s = t.rights; + MapReduceKeysToDoubleTask + t = (MapReduceKeysToDoubleTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsDouble(t.result, s.result); s = t.rights = s.nextRight; @@ -5725,46 +5942,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceValuesToDoubleTask - extends BulkTask { + static final class MapReduceValuesToDoubleTask + extends BulkTask { final ToDoubleFunction transformer; final DoubleBinaryOperator reducer; final double basis; double result; - MapReduceValuesToDoubleTask rights, nextRight; + MapReduceValuesToDoubleTask rights, nextRight; + MapReduceValuesToDoubleTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceValuesToDoubleTask nextRight, - ToDoubleFunction transformer, - double basis, - DoubleBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceValuesToDoubleTask nextRight, + ToDoubleFunction transformer, + double basis, + DoubleBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; } - public final Double getRawResult() { return result; } + + public final Double getRawResult() { + return result; + } + public final void compute() { final ToDoubleFunction transformer; final DoubleBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { double r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceValuesToDoubleTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceValuesToDoubleTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.val)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceValuesToDoubleTask - t = (MapReduceValuesToDoubleTask)c, - s = t.rights; + MapReduceValuesToDoubleTask + t = (MapReduceValuesToDoubleTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsDouble(t.result, s.result); s = t.rights = s.nextRight; @@ -5775,46 +5999,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceEntriesToDoubleTask - extends BulkTask { - final ToDoubleFunction> transformer; + static final class MapReduceEntriesToDoubleTask + extends BulkTask { + final ToDoubleFunction> transformer; final DoubleBinaryOperator reducer; final double basis; double result; - MapReduceEntriesToDoubleTask rights, nextRight; + MapReduceEntriesToDoubleTask rights, nextRight; + MapReduceEntriesToDoubleTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceEntriesToDoubleTask nextRight, - ToDoubleFunction> transformer, - double basis, - DoubleBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceEntriesToDoubleTask nextRight, + ToDoubleFunction> transformer, + double basis, + DoubleBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; + } + + public final Double getRawResult() { + return result; } - public final Double getRawResult() { return result; } + public final void compute() { - final ToDoubleFunction> transformer; + final ToDoubleFunction> transformer; final DoubleBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { double r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceEntriesToDoubleTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceEntriesToDoubleTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsDouble(r, transformer.applyAsDouble(p)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceEntriesToDoubleTask - t = (MapReduceEntriesToDoubleTask)c, - s = t.rights; + MapReduceEntriesToDoubleTask + t = (MapReduceEntriesToDoubleTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsDouble(t.result, s.result); s = t.rights = s.nextRight; @@ -5825,46 +6056,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceMappingsToDoubleTask - extends BulkTask { + static final class MapReduceMappingsToDoubleTask + extends BulkTask { final ToDoubleBiFunction transformer; final DoubleBinaryOperator reducer; final double basis; double result; - MapReduceMappingsToDoubleTask rights, nextRight; + MapReduceMappingsToDoubleTask rights, nextRight; + MapReduceMappingsToDoubleTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceMappingsToDoubleTask nextRight, - ToDoubleBiFunction transformer, - double basis, - DoubleBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceMappingsToDoubleTask nextRight, + ToDoubleBiFunction transformer, + double basis, + DoubleBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; } - public final Double getRawResult() { return result; } + + public final Double getRawResult() { + return result; + } + public final void compute() { final ToDoubleBiFunction transformer; final DoubleBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { double r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceMappingsToDoubleTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceMappingsToDoubleTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.key, p.val)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceMappingsToDoubleTask - t = (MapReduceMappingsToDoubleTask)c, - s = t.rights; + MapReduceMappingsToDoubleTask + t = (MapReduceMappingsToDoubleTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsDouble(t.result, s.result); s = t.rights = s.nextRight; @@ -5875,46 +6113,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceKeysToLongTask - extends BulkTask { + static final class MapReduceKeysToLongTask + extends BulkTask { final ToLongFunction transformer; final LongBinaryOperator reducer; final long basis; long result; - MapReduceKeysToLongTask rights, nextRight; + MapReduceKeysToLongTask rights, nextRight; + MapReduceKeysToLongTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceKeysToLongTask nextRight, - ToLongFunction transformer, - long basis, - LongBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceKeysToLongTask nextRight, + ToLongFunction transformer, + long basis, + LongBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; + } + + public final Long getRawResult() { + return result; } - public final Long getRawResult() { return result; } + public final void compute() { final ToLongFunction transformer; final LongBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { long r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceKeysToLongTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceKeysToLongTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsLong(r, transformer.applyAsLong(p.key)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceKeysToLongTask - t = (MapReduceKeysToLongTask)c, - s = t.rights; + MapReduceKeysToLongTask + t = (MapReduceKeysToLongTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsLong(t.result, s.result); s = t.rights = s.nextRight; @@ -5925,46 +6170,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceValuesToLongTask - extends BulkTask { + static final class MapReduceValuesToLongTask + extends BulkTask { final ToLongFunction transformer; final LongBinaryOperator reducer; final long basis; long result; - MapReduceValuesToLongTask rights, nextRight; + MapReduceValuesToLongTask rights, nextRight; + MapReduceValuesToLongTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceValuesToLongTask nextRight, - ToLongFunction transformer, - long basis, - LongBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceValuesToLongTask nextRight, + ToLongFunction transformer, + long basis, + LongBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; } - public final Long getRawResult() { return result; } + + public final Long getRawResult() { + return result; + } + public final void compute() { final ToLongFunction transformer; final LongBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { long r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceValuesToLongTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceValuesToLongTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsLong(r, transformer.applyAsLong(p.val)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceValuesToLongTask - t = (MapReduceValuesToLongTask)c, - s = t.rights; + MapReduceValuesToLongTask + t = (MapReduceValuesToLongTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsLong(t.result, s.result); s = t.rights = s.nextRight; @@ -5975,46 +6227,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceEntriesToLongTask - extends BulkTask { - final ToLongFunction> transformer; + static final class MapReduceEntriesToLongTask + extends BulkTask { + final ToLongFunction> transformer; final LongBinaryOperator reducer; final long basis; long result; - MapReduceEntriesToLongTask rights, nextRight; + MapReduceEntriesToLongTask rights, nextRight; + MapReduceEntriesToLongTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceEntriesToLongTask nextRight, - ToLongFunction> transformer, - long basis, - LongBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceEntriesToLongTask nextRight, + ToLongFunction> transformer, + long basis, + LongBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; + } + + public final Long getRawResult() { + return result; } - public final Long getRawResult() { return result; } + public final void compute() { - final ToLongFunction> transformer; + final ToLongFunction> transformer; final LongBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { long r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceEntriesToLongTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceEntriesToLongTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsLong(r, transformer.applyAsLong(p)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceEntriesToLongTask - t = (MapReduceEntriesToLongTask)c, - s = t.rights; + MapReduceEntriesToLongTask + t = (MapReduceEntriesToLongTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsLong(t.result, s.result); s = t.rights = s.nextRight; @@ -6025,46 +6284,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceMappingsToLongTask - extends BulkTask { + static final class MapReduceMappingsToLongTask + extends BulkTask { final ToLongBiFunction transformer; final LongBinaryOperator reducer; final long basis; long result; - MapReduceMappingsToLongTask rights, nextRight; + MapReduceMappingsToLongTask rights, nextRight; + MapReduceMappingsToLongTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceMappingsToLongTask nextRight, - ToLongBiFunction transformer, - long basis, - LongBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceMappingsToLongTask nextRight, + ToLongBiFunction transformer, + long basis, + LongBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; } - public final Long getRawResult() { return result; } + + public final Long getRawResult() { + return result; + } + public final void compute() { final ToLongBiFunction transformer; final LongBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { long r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceMappingsToLongTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceMappingsToLongTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsLong(r, transformer.applyAsLong(p.key, p.val)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceMappingsToLongTask - t = (MapReduceMappingsToLongTask)c, - s = t.rights; + MapReduceMappingsToLongTask + t = (MapReduceMappingsToLongTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsLong(t.result, s.result); s = t.rights = s.nextRight; @@ -6075,46 +6341,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceKeysToIntTask - extends BulkTask { + static final class MapReduceKeysToIntTask + extends BulkTask { final ToIntFunction transformer; final IntBinaryOperator reducer; final int basis; int result; - MapReduceKeysToIntTask rights, nextRight; + MapReduceKeysToIntTask rights, nextRight; + MapReduceKeysToIntTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceKeysToIntTask nextRight, - ToIntFunction transformer, - int basis, - IntBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceKeysToIntTask nextRight, + ToIntFunction transformer, + int basis, + IntBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; + } + + public final Integer getRawResult() { + return result; } - public final Integer getRawResult() { return result; } + public final void compute() { final ToIntFunction transformer; final IntBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { int r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceKeysToIntTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceKeysToIntTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsInt(r, transformer.applyAsInt(p.key)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceKeysToIntTask - t = (MapReduceKeysToIntTask)c, - s = t.rights; + MapReduceKeysToIntTask + t = (MapReduceKeysToIntTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsInt(t.result, s.result); s = t.rights = s.nextRight; @@ -6125,46 +6398,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceValuesToIntTask - extends BulkTask { + static final class MapReduceValuesToIntTask + extends BulkTask { final ToIntFunction transformer; final IntBinaryOperator reducer; final int basis; int result; - MapReduceValuesToIntTask rights, nextRight; + MapReduceValuesToIntTask rights, nextRight; + MapReduceValuesToIntTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceValuesToIntTask nextRight, - ToIntFunction transformer, - int basis, - IntBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceValuesToIntTask nextRight, + ToIntFunction transformer, + int basis, + IntBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; + } + + public final Integer getRawResult() { + return result; } - public final Integer getRawResult() { return result; } + public final void compute() { final ToIntFunction transformer; final IntBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { int r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceValuesToIntTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceValuesToIntTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsInt(r, transformer.applyAsInt(p.val)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceValuesToIntTask - t = (MapReduceValuesToIntTask)c, - s = t.rights; + MapReduceValuesToIntTask + t = (MapReduceValuesToIntTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsInt(t.result, s.result); s = t.rights = s.nextRight; @@ -6175,46 +6455,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceEntriesToIntTask - extends BulkTask { - final ToIntFunction> transformer; + static final class MapReduceEntriesToIntTask + extends BulkTask { + final ToIntFunction> transformer; final IntBinaryOperator reducer; final int basis; int result; - MapReduceEntriesToIntTask rights, nextRight; + MapReduceEntriesToIntTask rights, nextRight; + MapReduceEntriesToIntTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceEntriesToIntTask nextRight, - ToIntFunction> transformer, - int basis, - IntBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceEntriesToIntTask nextRight, + ToIntFunction> transformer, + int basis, + IntBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; } - public final Integer getRawResult() { return result; } + + public final Integer getRawResult() { + return result; + } + public final void compute() { - final ToIntFunction> transformer; + final ToIntFunction> transformer; final IntBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { int r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceEntriesToIntTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceEntriesToIntTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsInt(r, transformer.applyAsInt(p)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceEntriesToIntTask - t = (MapReduceEntriesToIntTask)c, - s = t.rights; + MapReduceEntriesToIntTask + t = (MapReduceEntriesToIntTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsInt(t.result, s.result); s = t.rights = s.nextRight; @@ -6225,46 +6512,53 @@ public class ConcurrentHashMap extends AbstractMap } @SuppressWarnings("serial") - static final class MapReduceMappingsToIntTask - extends BulkTask { + static final class MapReduceMappingsToIntTask + extends BulkTask { final ToIntBiFunction transformer; final IntBinaryOperator reducer; final int basis; int result; - MapReduceMappingsToIntTask rights, nextRight; + MapReduceMappingsToIntTask rights, nextRight; + MapReduceMappingsToIntTask - (BulkTask p, int b, int i, int f, Node[] t, - MapReduceMappingsToIntTask nextRight, - ToIntBiFunction transformer, - int basis, - IntBinaryOperator reducer) { - super(p, b, i, f, t); this.nextRight = nextRight; + (BulkTask p, int b, int i, int f, Node[] t, + MapReduceMappingsToIntTask nextRight, + ToIntBiFunction transformer, + int basis, + IntBinaryOperator reducer) { + super(p, b, i, f, t); + this.nextRight = nextRight; this.transformer = transformer; - this.basis = basis; this.reducer = reducer; + this.basis = basis; + this.reducer = reducer; + } + + public final Integer getRawResult() { + return result; } - public final Integer getRawResult() { return result; } + public final void compute() { final ToIntBiFunction transformer; final IntBinaryOperator reducer; if ((transformer = this.transformer) != null && - (reducer = this.reducer) != null) { + (reducer = this.reducer) != null) { int r = this.basis; for (int i = baseIndex, f, h; batch > 0 && - (h = ((f = baseLimit) + i) >>> 1) > i;) { + (h = ((f = baseLimit) + i) >>> 1) > i; ) { addToPendingCount(1); - (rights = new MapReduceMappingsToIntTask - (this, batch >>>= 1, baseLimit = h, f, tab, - rights, transformer, r, reducer)).fork(); + (rights = new MapReduceMappingsToIntTask + (this, batch >>>= 1, baseLimit = h, f, tab, + rights, transformer, r, reducer)).fork(); } - for (Node p; (p = advance()) != null; ) + for (Node p; (p = advance()) != null; ) r = reducer.applyAsInt(r, transformer.applyAsInt(p.key, p.val)); result = r; CountedCompleter c; for (c = firstComplete(); c != null; c = c.nextComplete()) { @SuppressWarnings("unchecked") - MapReduceMappingsToIntTask - t = (MapReduceMappingsToIntTask)c, - s = t.rights; + MapReduceMappingsToIntTask + t = (MapReduceMappingsToIntTask) c, + s = t.rights; while (s != null) { t.result = reducer.applyAsInt(t.result, s.result); s = t.rights = s.nextRight; @@ -6289,16 +6583,16 @@ public class ConcurrentHashMap extends AbstractMap U = sun.misc.Unsafe.getUnsafe(); Class k = ConcurrentHashMap.class; SIZECTL = U.objectFieldOffset - (k.getDeclaredField("sizeCtl")); + (k.getDeclaredField("sizeCtl")); TRANSFERINDEX = U.objectFieldOffset - (k.getDeclaredField("transferIndex")); + (k.getDeclaredField("transferIndex")); BASECOUNT = U.objectFieldOffset - (k.getDeclaredField("baseCount")); + (k.getDeclaredField("baseCount")); CELLSBUSY = U.objectFieldOffset - (k.getDeclaredField("cellsBusy")); + (k.getDeclaredField("cellsBusy")); Class ck = CounterCell.class; CELLVALUE = U.objectFieldOffset - (ck.getDeclaredField("value")); + (ck.getDeclaredField("value")); Class ak = Node[].class; ABASE = U.arrayBaseOffset(ak); int scale = U.arrayIndexScale(ak); -- GitLab