From 87062ca29f0c1d83f2df1e69c27c77ceb80fbb79 Mon Sep 17 00:00:00 2001 From: Doug Lea Date: Mon, 12 Dec 2011 10:45:54 +0000 Subject: [PATCH] 7118066: Warnings in java.util.concurrent package Reviewed-by: chegar, dholmes --- .../util/concurrent/ArrayBlockingQueue.java | 14 +- .../util/concurrent/ConcurrentHashMap.java | 45 ++++--- .../concurrent/ConcurrentLinkedDeque.java | 4 +- .../concurrent/ConcurrentLinkedQueue.java | 4 +- .../concurrent/ConcurrentSkipListMap.java | 126 +++++++++--------- .../concurrent/ConcurrentSkipListSet.java | 19 ++- .../util/concurrent/CopyOnWriteArrayList.java | 11 +- .../java/util/concurrent/DelayQueue.java | 2 +- .../java/util/concurrent/Exchanger.java | 20 +-- .../java/util/concurrent/ForkJoinPool.java | 4 +- .../java/util/concurrent/ForkJoinTask.java | 2 +- .../util/concurrent/ForkJoinWorkerThread.java | 8 +- .../util/concurrent/LinkedTransferQueue.java | 30 ++--- .../classes/java/util/concurrent/Phaser.java | 2 +- .../concurrent/PriorityBlockingQueue.java | 5 +- .../ScheduledThreadPoolExecutor.java | 88 ++++++------ .../util/concurrent/SynchronousQueue.java | 73 +++++----- .../java/util/Collections/EmptyIterator.java | 2 - 18 files changed, 242 insertions(+), 217 deletions(-) diff --git a/jdk/src/share/classes/java/util/concurrent/ArrayBlockingQueue.java b/jdk/src/share/classes/java/util/concurrent/ArrayBlockingQueue.java index 32fd50470d6..74f1e985523 100644 --- a/jdk/src/share/classes/java/util/concurrent/ArrayBlockingQueue.java +++ b/jdk/src/share/classes/java/util/concurrent/ArrayBlockingQueue.java @@ -131,8 +131,9 @@ public class ArrayBlockingQueue extends AbstractQueue /** * Returns item at index i. */ + @SuppressWarnings("unchecked") final E itemAt(int i) { - return this.cast(items[i]); + return (E) items[i]; } /** @@ -162,7 +163,8 @@ public class ArrayBlockingQueue extends AbstractQueue */ private E extract() { final Object[] items = this.items; - E x = this.cast(items[takeIndex]); + @SuppressWarnings("unchecked") + E x = (E) items[takeIndex]; items[takeIndex] = null; takeIndex = inc(takeIndex); --count; @@ -647,7 +649,9 @@ public class ArrayBlockingQueue extends AbstractQueue int n = 0; int max = count; while (n < max) { - c.add(this.cast(items[i])); + @SuppressWarnings("unchecked") + E x = (E) items[i]; + c.add(x); items[i] = null; i = inc(i); ++n; @@ -684,7 +688,9 @@ public class ArrayBlockingQueue extends AbstractQueue int n = 0; int max = (maxElements < count) ? maxElements : count; while (n < max) { - c.add(this.cast(items[i])); + @SuppressWarnings("unchecked") + E x = (E) items[i]; + c.add(x); items[i] = null; i = inc(i); ++n; diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java index e82148069b4..48b00212ed2 100644 --- a/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java +++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java @@ -37,9 +37,6 @@ package java.util.concurrent; import java.util.concurrent.locks.*; import java.util.*; import java.io.Serializable; -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; /** * A hash table supporting full concurrency of retrievals and @@ -228,7 +225,7 @@ public class ConcurrentHashMap extends AbstractMap static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = HashEntry.class; + Class k = HashEntry.class; nextOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("next")); } catch (Exception e) { @@ -433,7 +430,7 @@ public class ConcurrentHashMap extends AbstractMap int newCapacity = oldCapacity << 1; threshold = (int)(newCapacity * loadFactor); HashEntry[] newTable = - (HashEntry[]) new HashEntry[newCapacity]; + (HashEntry[]) new HashEntry[newCapacity]; int sizeMask = newCapacity - 1; for (int i = 0; i < oldCapacity ; i++) { HashEntry e = oldTable[i]; @@ -677,7 +674,7 @@ public class ConcurrentHashMap extends AbstractMap int cap = proto.table.length; float lf = proto.loadFactor; int threshold = (int)(cap * lf); - HashEntry[] tab = (HashEntry[])new HashEntry[cap]; + HashEntry[] tab = (HashEntry[])new HashEntry[cap]; if ((seg = (Segment)UNSAFE.getObjectVolatile(ss, u)) == null) { // recheck Segment s = new Segment(lf, threshold, tab); @@ -694,7 +691,7 @@ public class ConcurrentHashMap extends AbstractMap // Hash-based segment and entry accesses /** - * Get the segment for the given hash + * Gets the segment for the given hash code. */ @SuppressWarnings("unchecked") private Segment segmentForHash(int h) { @@ -703,7 +700,7 @@ public class ConcurrentHashMap extends AbstractMap } /** - * Gets the table entry for the given segment and hash + * Gets the table entry for the given segment and hash code. */ @SuppressWarnings("unchecked") static final HashEntry entryForHash(Segment seg, int h) { @@ -758,8 +755,8 @@ public class ConcurrentHashMap extends AbstractMap // create segments and segments[0] Segment s0 = new Segment(loadFactor, (int)(cap * loadFactor), - (HashEntry[])new HashEntry[cap]); - Segment[] ss = (Segment[])new Segment[ssize]; + (HashEntry[])new HashEntry[cap]); + Segment[] ss = (Segment[])new Segment[ssize]; UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0] this.segments = ss; } @@ -916,6 +913,7 @@ public class ConcurrentHashMap extends AbstractMap * * @throws NullPointerException if the specified key is null */ + @SuppressWarnings("unchecked") public V get(Object key) { Segment s; // manually integrate access methods to reduce overhead HashEntry[] tab; @@ -1026,7 +1024,7 @@ public class ConcurrentHashMap extends AbstractMap * full compatibility with class {@link java.util.Hashtable}, * which supported this method prior to introduction of the * Java Collections framework. - + * * @param value a value to search for * @return true if and only if some key maps to the * value argument in this table as @@ -1262,7 +1260,7 @@ public class ConcurrentHashMap extends AbstractMap } /** - * Set nextEntry to first node of next non-empty table + * Sets nextEntry to first node of next non-empty table * (in backwards order, to simplify checks). */ final void advance() { @@ -1326,12 +1324,14 @@ public class ConcurrentHashMap extends AbstractMap final class WriteThroughEntry extends AbstractMap.SimpleEntry { + static final long serialVersionUID = 7249069246763182397L; + WriteThroughEntry(K k, V v) { super(k,v); } /** - * Set our entry's value and write through to the map. The + * Sets our entry's value and writes through to the map. The * value to return is somewhat arbitrary here. Since a * WriteThroughEntry does not necessarily track asynchronous * changes, the most recent "previous" value could be @@ -1427,15 +1427,16 @@ public class ConcurrentHashMap extends AbstractMap /* ---------------- Serialization Support -------------- */ /** - * Save the state of the ConcurrentHashMap instance to a - * stream (i.e., serialize it). + * Saves the state of the ConcurrentHashMap instance to a + * stream (i.e., serializes it). * @param s the stream * @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 IOException { + private void writeObject(java.io.ObjectOutputStream s) + throws java.io.IOException { // force all segments for serialization compatibility for (int k = 0; k < segments.length; ++k) ensureSegment(k); @@ -1463,13 +1464,13 @@ public class ConcurrentHashMap extends AbstractMap } /** - * Reconstitute the ConcurrentHashMap instance from a - * stream (i.e., deserialize it). + * Reconstitutes the ConcurrentHashMap instance from a + * stream (i.e., deserializes it). * @param s the stream */ @SuppressWarnings("unchecked") private void readObject(java.io.ObjectInputStream s) - throws IOException, ClassNotFoundException { + throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); // Re-initialize segments to be minimally sized, and let grow. @@ -1479,7 +1480,7 @@ public class ConcurrentHashMap extends AbstractMap Segment seg = segments[k]; if (seg != null) { seg.threshold = (int)(cap * seg.loadFactor); - seg.table = (HashEntry[]) new HashEntry[cap]; + seg.table = (HashEntry[]) new HashEntry[cap]; } } @@ -1504,8 +1505,8 @@ public class ConcurrentHashMap extends AbstractMap int ss, ts; try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class tc = HashEntry[].class; - Class sc = Segment[].class; + Class tc = HashEntry[].class; + Class sc = Segment[].class; TBASE = UNSAFE.arrayBaseOffset(tc); SBASE = UNSAFE.arrayBaseOffset(sc); ts = UNSAFE.arrayIndexScale(tc); diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java index 21d59cfc460..c26e371f9d1 100644 --- a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java +++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java @@ -335,7 +335,7 @@ public class ConcurrentLinkedDeque static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = Node.class; + Class k = Node.class; prevOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("prev")); itemOffset = UNSAFE.objectFieldOffset @@ -1457,7 +1457,7 @@ public class ConcurrentLinkedDeque NEXT_TERMINATOR.prev = NEXT_TERMINATOR; try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = ConcurrentLinkedDeque.class; + Class k = ConcurrentLinkedDeque.class; headOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("head")); tailOffset = UNSAFE.objectFieldOffset diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java index fcdfcf97eb6..dfac05c6d40 100644 --- a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java +++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java @@ -208,7 +208,7 @@ public class ConcurrentLinkedQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = Node.class; + Class k = Node.class; itemOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("item")); nextOffset = UNSAFE.objectFieldOffset @@ -823,7 +823,7 @@ public class ConcurrentLinkedQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = ConcurrentLinkedQueue.class; + Class k = ConcurrentLinkedQueue.class; headOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("head")); tailOffset = UNSAFE.objectFieldOffset diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java index 8d23964512b..fdf83d1cc81 100644 --- a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java +++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java @@ -35,7 +35,6 @@ package java.util.concurrent; import java.util.*; -import java.util.concurrent.atomic.*; /** * A scalable concurrent {@link ConcurrentNavigableMap} implementation. @@ -90,6 +89,7 @@ import java.util.concurrent.atomic.*; * @param the type of mapped values * @since 1.6 */ +@SuppressWarnings("unchecked") public class ConcurrentSkipListMap extends AbstractMap implements ConcurrentNavigableMap, Cloneable, @@ -352,11 +352,11 @@ public class ConcurrentSkipListMap extends AbstractMap private transient int randomSeed; /** Lazily initialized key set */ - private transient KeySet keySet; + private transient KeySet keySet; /** Lazily initialized entry set */ - private transient EntrySet entrySet; + private transient EntrySet entrySet; /** Lazily initialized values collection */ - private transient Values values; + private transient Values values; /** Lazily initialized descending key set */ private transient ConcurrentNavigableMap descendingMap; @@ -517,7 +517,7 @@ public class ConcurrentSkipListMap extends AbstractMap static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = Node.class; + Class k = Node.class; valueOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("value")); nextOffset = UNSAFE.objectFieldOffset @@ -597,7 +597,7 @@ public class ConcurrentSkipListMap extends AbstractMap static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = Index.class; + Class k = Index.class; rightOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("right")); } catch (Exception e) { @@ -933,7 +933,7 @@ public class ConcurrentSkipListMap extends AbstractMap * direction. */ level = max + 1; - Index[] idxs = (Index[])new Index[level+1]; + Index[] idxs = (Index[])new Index[level+1]; Index idx = null; for (int i = 1; i <= level; ++i) idxs[i] = idx = new Index(z, idx, null); @@ -1436,16 +1436,16 @@ public class ConcurrentSkipListMap extends AbstractMap * @return a shallow copy of this map */ public ConcurrentSkipListMap clone() { - ConcurrentSkipListMap clone = null; try { - clone = (ConcurrentSkipListMap) super.clone(); + @SuppressWarnings("unchecked") + ConcurrentSkipListMap clone = + (ConcurrentSkipListMap) super.clone(); + clone.initialize(); + clone.buildFromSorted(this); + return clone; } catch (CloneNotSupportedException e) { throw new InternalError(); } - - clone.initialize(); - clone.buildFromSorted(this); - return clone; } /** @@ -1507,7 +1507,7 @@ public class ConcurrentSkipListMap extends AbstractMap /* ---------------- Serialization -------------- */ /** - * Save the state of this map to a stream. + * Saves the state of this map to a stream (that is, serializes it). * * @serialData The key (Object) and value (Object) for each * key-value mapping represented by the map, followed by @@ -1532,7 +1532,9 @@ public class ConcurrentSkipListMap extends AbstractMap } /** - * Reconstitute the map from a stream. + * Reconstitutes the map from a stream (that is, deserializes it). + * + * @param s the stream */ private void readObject(final java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { @@ -1755,13 +1757,13 @@ public class ConcurrentSkipListMap extends AbstractMap * @return a navigable set view of the keys in this map */ public NavigableSet keySet() { - KeySet ks = keySet; - return (ks != null) ? ks : (keySet = new KeySet(this)); + KeySet ks = keySet; + return (ks != null) ? ks : (keySet = new KeySet(this)); } public NavigableSet navigableKeySet() { - KeySet ks = keySet; - return (ks != null) ? ks : (keySet = new KeySet(this)); + KeySet ks = keySet; + return (ks != null) ? ks : (keySet = new KeySet(this)); } /** @@ -1783,8 +1785,8 @@ public class ConcurrentSkipListMap extends AbstractMap * reflect any modifications subsequent to construction. */ public Collection values() { - Values vs = values; - return (vs != null) ? vs : (values = new Values(this)); + Values vs = values; + return (vs != null) ? vs : (values = new Values(this)); } /** @@ -1812,8 +1814,8 @@ public class ConcurrentSkipListMap extends AbstractMap * sorted in ascending key order */ public Set> entrySet() { - EntrySet es = entrySet; - return (es != null) ? es : (entrySet = new EntrySet(this)); + EntrySet es = entrySet; + return (es != null) ? es : (entrySet = new EntrySet(this)); } public ConcurrentNavigableMap descendingMap() { @@ -2304,8 +2306,8 @@ public class ConcurrentSkipListMap extends AbstractMap static final class KeySet extends AbstractSet implements NavigableSet { - private final ConcurrentNavigableMap m; - KeySet(ConcurrentNavigableMap map) { m = map; } + private final ConcurrentNavigableMap m; + KeySet(ConcurrentNavigableMap map) { m = map; } public int size() { return m.size(); } public boolean isEmpty() { return m.isEmpty(); } public boolean contains(Object o) { return m.containsKey(o); } @@ -2319,11 +2321,11 @@ public class ConcurrentSkipListMap extends AbstractMap public E first() { return m.firstKey(); } public E last() { return m.lastKey(); } public E pollFirst() { - Map.Entry e = m.pollFirstEntry(); + Map.Entry e = m.pollFirstEntry(); return (e == null) ? null : e.getKey(); } public E pollLast() { - Map.Entry e = m.pollLastEntry(); + Map.Entry e = m.pollLastEntry(); return (e == null) ? null : e.getKey(); } public Iterator iterator() { @@ -2374,20 +2376,20 @@ public class ConcurrentSkipListMap extends AbstractMap return tailSet(fromElement, true); } public NavigableSet descendingSet() { - return new KeySet(m.descendingMap()); + return new KeySet(m.descendingMap()); } } static final class Values extends AbstractCollection { - private final ConcurrentNavigableMap m; - Values(ConcurrentNavigableMap map) { + private final ConcurrentNavigableMap m; + Values(ConcurrentNavigableMap map) { m = map; } public Iterator iterator() { if (m instanceof ConcurrentSkipListMap) - return ((ConcurrentSkipListMap)m).valueIterator(); + return ((ConcurrentSkipListMap)m).valueIterator(); else - return ((SubMap)m).valueIterator(); + return ((SubMap)m).valueIterator(); } public boolean isEmpty() { return m.isEmpty(); @@ -2421,14 +2423,14 @@ public class ConcurrentSkipListMap extends AbstractMap public boolean contains(Object o) { if (!(o instanceof Map.Entry)) return false; - Map.Entry e = (Map.Entry)o; + Map.Entry e = (Map.Entry)o; V1 v = m.get(e.getKey()); return v != null && v.equals(e.getValue()); } public boolean remove(Object o) { if (!(o instanceof Map.Entry)) return false; - Map.Entry e = (Map.Entry)o; + Map.Entry e = (Map.Entry)o; return m.remove(e.getKey(), e.getValue()); } @@ -2568,9 +2570,9 @@ public class ConcurrentSkipListMap extends AbstractMap if (lo == null) return m.findFirst(); else if (loInclusive) - return m.findNear(lo, m.GT|m.EQ); + return m.findNear(lo, GT|EQ); else - return m.findNear(lo, m.GT); + return m.findNear(lo, GT); } /** @@ -2581,9 +2583,9 @@ public class ConcurrentSkipListMap extends AbstractMap if (hi == null) return m.findLast(); else if (hiInclusive) - return m.findNear(hi, m.LT|m.EQ); + return m.findNear(hi, LT|EQ); else - return m.findNear(hi, m.LT); + return m.findNear(hi, LT); } /** @@ -2665,15 +2667,15 @@ public class ConcurrentSkipListMap extends AbstractMap */ private Map.Entry getNearEntry(K key, int rel) { if (isDescending) { // adjust relation for direction - if ((rel & m.LT) == 0) - rel |= m.LT; + if ((rel & LT) == 0) + rel |= LT; else - rel &= ~m.LT; + rel &= ~LT; } if (tooLow(key)) - return ((rel & m.LT) != 0) ? null : lowestEntry(); + return ((rel & LT) != 0) ? null : lowestEntry(); if (tooHigh(key)) - return ((rel & m.LT) != 0) ? highestEntry() : null; + return ((rel & LT) != 0) ? highestEntry() : null; for (;;) { Node n = m.findNear(key, rel); if (n == null || !inBounds(n.key)) @@ -2688,13 +2690,13 @@ public class ConcurrentSkipListMap extends AbstractMap // Almost the same as getNearEntry, except for keys private K getNearKey(K key, int rel) { if (isDescending) { // adjust relation for direction - if ((rel & m.LT) == 0) - rel |= m.LT; + if ((rel & LT) == 0) + rel |= LT; else - rel &= ~m.LT; + rel &= ~LT; } if (tooLow(key)) { - if ((rel & m.LT) == 0) { + if ((rel & LT) == 0) { ConcurrentSkipListMap.Node n = loNode(); if (isBeforeEnd(n)) return n.key; @@ -2702,7 +2704,7 @@ public class ConcurrentSkipListMap extends AbstractMap return null; } if (tooHigh(key)) { - if ((rel & m.LT) != 0) { + if ((rel & LT) != 0) { ConcurrentSkipListMap.Node n = hiNode(); if (n != null) { K last = n.key; @@ -2734,7 +2736,7 @@ public class ConcurrentSkipListMap extends AbstractMap public V get(Object key) { if (key == null) throw new NullPointerException(); K k = (K)key; - return ((!inBounds(k)) ? null : m.get(k)); + return (!inBounds(k)) ? null : m.get(k); } public V put(K key, V value) { @@ -2901,35 +2903,35 @@ public class ConcurrentSkipListMap extends AbstractMap /* ---------------- Relational methods -------------- */ public Map.Entry ceilingEntry(K key) { - return getNearEntry(key, (m.GT|m.EQ)); + return getNearEntry(key, GT|EQ); } public K ceilingKey(K key) { - return getNearKey(key, (m.GT|m.EQ)); + return getNearKey(key, GT|EQ); } public Map.Entry lowerEntry(K key) { - return getNearEntry(key, (m.LT)); + return getNearEntry(key, LT); } public K lowerKey(K key) { - return getNearKey(key, (m.LT)); + return getNearKey(key, LT); } public Map.Entry floorEntry(K key) { - return getNearEntry(key, (m.LT|m.EQ)); + return getNearEntry(key, LT|EQ); } public K floorKey(K key) { - return getNearKey(key, (m.LT|m.EQ)); + return getNearKey(key, LT|EQ); } public Map.Entry higherEntry(K key) { - return getNearEntry(key, (m.GT)); + return getNearEntry(key, GT); } public K higherKey(K key) { - return getNearKey(key, (m.GT)); + return getNearKey(key, GT); } public K firstKey() { @@ -2960,22 +2962,22 @@ public class ConcurrentSkipListMap extends AbstractMap public NavigableSet keySet() { KeySet ks = keySetView; - return (ks != null) ? ks : (keySetView = new KeySet(this)); + return (ks != null) ? ks : (keySetView = new KeySet(this)); } public NavigableSet navigableKeySet() { KeySet ks = keySetView; - return (ks != null) ? ks : (keySetView = new KeySet(this)); + return (ks != null) ? ks : (keySetView = new KeySet(this)); } public Collection values() { Collection vs = valuesView; - return (vs != null) ? vs : (valuesView = new Values(this)); + return (vs != null) ? vs : (valuesView = new Values(this)); } public Set> entrySet() { Set> es = entrySetView; - return (es != null) ? es : (entrySetView = new EntrySet(this)); + return (es != null) ? es : (entrySetView = new EntrySet(this)); } public NavigableSet descendingKeySet() { @@ -3109,7 +3111,7 @@ public class ConcurrentSkipListMap extends AbstractMap static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = ConcurrentSkipListMap.class; + Class k = ConcurrentSkipListMap.class; headOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("head")); } catch (Exception e) { diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java index 7b5dc79a932..b250c1a5108 100644 --- a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java +++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java @@ -35,7 +35,6 @@ package java.util.concurrent; import java.util.*; -import sun.misc.Unsafe; /** * A scalable concurrent {@link NavigableSet} implementation based on @@ -158,15 +157,15 @@ public class ConcurrentSkipListSet * @return a shallow copy of this set */ public ConcurrentSkipListSet clone() { - ConcurrentSkipListSet clone = null; try { - clone = (ConcurrentSkipListSet) super.clone(); - clone.setMap(new ConcurrentSkipListMap(m)); + @SuppressWarnings("unchecked") + ConcurrentSkipListSet clone = + (ConcurrentSkipListSet) super.clone(); + clone.setMap(new ConcurrentSkipListMap(m)); + return clone; } catch (CloneNotSupportedException e) { throw new InternalError(); } - - return clone; } /* ---------------- Set operations -------------- */ @@ -322,8 +321,8 @@ public class ConcurrentSkipListSet public boolean removeAll(Collection c) { // Override AbstractSet version to avoid unnecessary call to size() boolean modified = false; - for (Iterator i = c.iterator(); i.hasNext(); ) - if (remove(i.next())) + for (Object e : c) + if (remove(e)) modified = true; return modified; } @@ -468,7 +467,7 @@ public class ConcurrentSkipListSet * @return a reverse order view of this set */ public NavigableSet descendingSet() { - return new ConcurrentSkipListSet(m.descendingMap()); + return new ConcurrentSkipListSet(m.descendingMap()); } // Support for resetting map in clone @@ -481,7 +480,7 @@ public class ConcurrentSkipListSet static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = ConcurrentSkipListSet.class; + Class k = ConcurrentSkipListSet.class; mapOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("m")); } catch (Exception e) { diff --git a/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java b/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java index 785ec6fcede..e61dd7921fd 100644 --- a/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java +++ b/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java @@ -36,7 +36,6 @@ package java.util.concurrent; import java.util.*; import java.util.concurrent.locks.*; -import sun.misc.Unsafe; /** * A thread-safe variant of {@link java.util.ArrayList} in which all mutative @@ -281,9 +280,11 @@ public class CopyOnWriteArrayList */ public Object clone() { try { - CopyOnWriteArrayList c = (CopyOnWriteArrayList)(super.clone()); - c.resetLock(); - return c; + @SuppressWarnings("unchecked") + CopyOnWriteArrayList clone = + (CopyOnWriteArrayList) super.clone(); + clone.resetLock(); + return clone; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(); @@ -1330,7 +1331,7 @@ public class CopyOnWriteArrayList static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = CopyOnWriteArrayList.class; + Class k = CopyOnWriteArrayList.class; lockOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("lock")); } catch (Exception e) { diff --git a/jdk/src/share/classes/java/util/concurrent/DelayQueue.java b/jdk/src/share/classes/java/util/concurrent/DelayQueue.java index dd36cc79ac2..aa68b749d7b 100644 --- a/jdk/src/share/classes/java/util/concurrent/DelayQueue.java +++ b/jdk/src/share/classes/java/util/concurrent/DelayQueue.java @@ -531,7 +531,7 @@ public class DelayQueue extends AbstractQueue // not just a .equals element. lock.lock(); try { - for (Iterator it = q.iterator(); it.hasNext(); ) { + for (Iterator it = q.iterator(); it.hasNext(); ) { if (it.next() == x) { it.remove(); return; diff --git a/jdk/src/share/classes/java/util/concurrent/Exchanger.java b/jdk/src/share/classes/java/util/concurrent/Exchanger.java index 99e3a35967b..5accdb1ce58 100644 --- a/jdk/src/share/classes/java/util/concurrent/Exchanger.java +++ b/jdk/src/share/classes/java/util/concurrent/Exchanger.java @@ -279,6 +279,7 @@ public class Exchanger { * into hole. This class cannot be parameterized as "V" because * of the use of non-V CANCEL sentinels. */ + @SuppressWarnings("serial") private static final class Node extends AtomicReference { /** The element offered by the Thread creating this node. */ public final Object item; @@ -303,6 +304,7 @@ public class Exchanger { * would improve throughput more than enough to outweigh using * extra space. */ + @SuppressWarnings("serial") private static final class Slot extends AtomicReference { // Improve likelihood of isolation on <= 64 byte cache lines long q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe; @@ -616,13 +618,14 @@ public class Exchanger { * @throws InterruptedException if the current thread was * interrupted while waiting */ + @SuppressWarnings("unchecked") public V exchange(V x) throws InterruptedException { if (!Thread.interrupted()) { - Object v = doExchange((x == null) ? NULL_ITEM : x, false, 0); - if (v == NULL_ITEM) + Object o = doExchange((x == null) ? NULL_ITEM : x, false, 0); + if (o == NULL_ITEM) return null; - if (v != CANCEL) - return (V)v; + if (o != CANCEL) + return (V)o; Thread.interrupted(); // Clear interrupt status on IE throw } throw new InterruptedException(); @@ -670,15 +673,16 @@ public class Exchanger { * @throws TimeoutException if the specified waiting time elapses * before another thread enters the exchange */ + @SuppressWarnings("unchecked") public V exchange(V x, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException { if (!Thread.interrupted()) { - Object v = doExchange((x == null) ? NULL_ITEM : x, + Object o = doExchange((x == null) ? NULL_ITEM : x, true, unit.toNanos(timeout)); - if (v == NULL_ITEM) + if (o == NULL_ITEM) return null; - if (v != CANCEL) - return (V)v; + if (o != CANCEL) + return (V)o; if (!Thread.interrupted()) throw new TimeoutException(); } diff --git a/jdk/src/share/classes/java/util/concurrent/ForkJoinPool.java b/jdk/src/share/classes/java/util/concurrent/ForkJoinPool.java index 9c90f36adb4..0887e83f0e8 100644 --- a/jdk/src/share/classes/java/util/concurrent/ForkJoinPool.java +++ b/jdk/src/share/classes/java/util/concurrent/ForkJoinPool.java @@ -2150,7 +2150,7 @@ public class ForkJoinPool extends AbstractExecutorService { int s; try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = ForkJoinPool.class; + Class k = ForkJoinPool.class; ctlOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("ctl")); stealCountOffset = UNSAFE.objectFieldOffset @@ -2163,7 +2163,7 @@ public class ForkJoinPool extends AbstractExecutorService { (k.getDeclaredField("scanGuard")); nextWorkerNumberOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("nextWorkerNumber")); - Class a = ForkJoinTask[].class; + Class a = ForkJoinTask[].class; ABASE = UNSAFE.arrayBaseOffset(a); s = UNSAFE.arrayIndexScale(a); } catch (Exception e) { diff --git a/jdk/src/share/classes/java/util/concurrent/ForkJoinTask.java b/jdk/src/share/classes/java/util/concurrent/ForkJoinTask.java index fbab843f78b..de4b1231359 100644 --- a/jdk/src/share/classes/java/util/concurrent/ForkJoinTask.java +++ b/jdk/src/share/classes/java/util/concurrent/ForkJoinTask.java @@ -520,7 +520,7 @@ public abstract class ForkJoinTask implements Future, Serializable { if (e == null || (ex = e.ex) == null) return null; if (e.thrower != Thread.currentThread().getId()) { - Class ec = ex.getClass(); + Class ec = ex.getClass(); try { Constructor noArgCtor = null; Constructor[] cs = ec.getConstructors();// public ctors only diff --git a/jdk/src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java b/jdk/src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java index 3504abb73c7..c60b23b1bbe 100644 --- a/jdk/src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java +++ b/jdk/src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java @@ -192,7 +192,7 @@ public class ForkJoinWorkerThread extends Thread { /** * The work-stealing queue array. Size must be a power of two. - * Initialized when started (as oposed to when constructed), to + * Initialized when started (as opposed to when constructed), to * improve memory locality. */ ForkJoinTask[] queue; @@ -360,7 +360,7 @@ public class ForkJoinWorkerThread extends Thread { */ protected void onStart() { queue = new ForkJoinTask[INITIAL_QUEUE_CAPACITY]; - int r = pool.workerSeedGenerator.nextInt(); + int r = ForkJoinPool.workerSeedGenerator.nextInt(); seed = (r == 0) ? 1 : r; // must be nonzero } @@ -846,7 +846,7 @@ public class ForkJoinWorkerThread extends Thread { (b = v.queueBase) != v.queueTop && (q = v.queue) != null && (i = (q.length - 1) & b) >= 0 && - q[i] == t) { + q[i] == t) { long u = (i << ASHIFT) + ABASE; if (v.queueBase == b && UNSAFE.compareAndSwapObject(q, u, t, null)) { @@ -984,7 +984,7 @@ public class ForkJoinWorkerThread extends Thread { int s; try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class a = ForkJoinTask[].class; + Class a = ForkJoinTask[].class; ABASE = UNSAFE.arrayBaseOffset(a); s = UNSAFE.arrayIndexScale(a); } catch (Exception e) { diff --git a/jdk/src/share/classes/java/util/concurrent/LinkedTransferQueue.java b/jdk/src/share/classes/java/util/concurrent/LinkedTransferQueue.java index ebdf223ff6c..171523f1643 100644 --- a/jdk/src/share/classes/java/util/concurrent/LinkedTransferQueue.java +++ b/jdk/src/share/classes/java/util/concurrent/LinkedTransferQueue.java @@ -330,8 +330,8 @@ public class LinkedTransferQueue extends AbstractQueue * of less-contended queues. During spins threads check their * interrupt status and generate a thread-local random number * to decide to occasionally perform a Thread.yield. While - * yield has underdefined specs, we assume that might it help, - * and will not hurt in limiting impact of spinning on busy + * yield has underdefined specs, we assume that it might help, + * and will not hurt, in limiting impact of spinning on busy * systems. We also use smaller (1/2) spins for nodes that are * not known to be front but whose predecessors have not * blocked -- these "chained" spins avoid artifacts of @@ -542,7 +542,7 @@ public class LinkedTransferQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = Node.class; + Class k = Node.class; itemOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("item")); nextOffset = UNSAFE.objectFieldOffset @@ -627,7 +627,7 @@ public class LinkedTransferQueue extends AbstractQueue break; // unless slack < 2 } LockSupport.unpark(p.waiter); - return this.cast(item); + return LinkedTransferQueue.cast(item); } } Node n = p.next; @@ -705,7 +705,7 @@ public class LinkedTransferQueue extends AbstractQueue if (item != e) { // matched // assert item != s; s.forgetContents(); // avoid garbage - return this.cast(item); + return LinkedTransferQueue.cast(item); } if ((w.isInterrupted() || (timed && nanos <= 0)) && s.casItem(e, s)) { // cancel @@ -786,7 +786,7 @@ public class LinkedTransferQueue extends AbstractQueue Object item = p.item; if (p.isData) { if (item != null && item != p) - return this.cast(item); + return LinkedTransferQueue.cast(item); } else if (item == null) return null; @@ -1008,7 +1008,6 @@ public class LinkedTransferQueue extends AbstractQueue return false; } - /** * Creates an initially empty {@code LinkedTransferQueue}. */ @@ -1045,7 +1044,8 @@ public class LinkedTransferQueue extends AbstractQueue * return {@code false}. * * @return {@code true} (as specified by - * {@link BlockingQueue#offer(Object,long,TimeUnit) BlockingQueue.offer}) + * {@link java.util.concurrent.BlockingQueue#offer(Object,long,TimeUnit) + * BlockingQueue.offer}) * @throws NullPointerException if the specified element is null */ public boolean offer(E e, long timeout, TimeUnit unit) { @@ -1162,8 +1162,7 @@ public class LinkedTransferQueue extends AbstractQueue if (c == this) throw new IllegalArgumentException(); int n = 0; - E e; - while ( (e = poll()) != null) { + for (E e; (e = poll()) != null;) { c.add(e); ++n; } @@ -1180,8 +1179,7 @@ public class LinkedTransferQueue extends AbstractQueue if (c == this) throw new IllegalArgumentException(); int n = 0; - E e; - while (n < maxElements && (e = poll()) != null) { + for (E e; n < maxElements && (e = poll()) != null;) { c.add(e); ++n; } @@ -1288,7 +1286,8 @@ public class LinkedTransferQueue extends AbstractQueue * {@code LinkedTransferQueue} is not capacity constrained. * * @return {@code Integer.MAX_VALUE} (as specified by - * {@link BlockingQueue#remainingCapacity()}) + * {@link java.util.concurrent.BlockingQueue#remainingCapacity() + * BlockingQueue.remainingCapacity}) */ public int remainingCapacity() { return Integer.MAX_VALUE; @@ -1320,7 +1319,8 @@ public class LinkedTransferQueue extends AbstractQueue throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); for (;;) { - @SuppressWarnings("unchecked") E item = (E) s.readObject(); + @SuppressWarnings("unchecked") + E item = (E) s.readObject(); if (item == null) break; else @@ -1337,7 +1337,7 @@ public class LinkedTransferQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = LinkedTransferQueue.class; + Class k = LinkedTransferQueue.class; headOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("head")); tailOffset = UNSAFE.objectFieldOffset diff --git a/jdk/src/share/classes/java/util/concurrent/Phaser.java b/jdk/src/share/classes/java/util/concurrent/Phaser.java index bdafbbb7a9d..c8afecc3c00 100644 --- a/jdk/src/share/classes/java/util/concurrent/Phaser.java +++ b/jdk/src/share/classes/java/util/concurrent/Phaser.java @@ -1142,7 +1142,7 @@ public class Phaser { static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = Phaser.class; + Class k = Phaser.class; stateOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("state")); } catch (Exception e) { diff --git a/jdk/src/share/classes/java/util/concurrent/PriorityBlockingQueue.java b/jdk/src/share/classes/java/util/concurrent/PriorityBlockingQueue.java index 83dbb4dd778..37b44a1038e 100644 --- a/jdk/src/share/classes/java/util/concurrent/PriorityBlockingQueue.java +++ b/jdk/src/share/classes/java/util/concurrent/PriorityBlockingQueue.java @@ -94,6 +94,7 @@ import java.util.*; * @author Doug Lea * @param the type of elements held in this collection */ +@SuppressWarnings("unchecked") public class PriorityBlockingQueue extends AbstractQueue implements BlockingQueue, java.io.Serializable { private static final long serialVersionUID = 5595510919245408276L; @@ -168,7 +169,7 @@ public class PriorityBlockingQueue extends AbstractQueue * to maintain compatibility with previous versions * of this class. Non-null only during serialization/deserialization. */ - private PriorityQueue q; + private PriorityQueue q; /** * Creates a {@code PriorityBlockingQueue} with the default @@ -968,7 +969,7 @@ public class PriorityBlockingQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = PriorityBlockingQueue.class; + Class k = PriorityBlockingQueue.class; allocationSpinLockOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("allocationSpinLock")); } catch (Exception e) { diff --git a/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java b/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java index 5101a9c458e..49195b87c69 100644 --- a/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java +++ b/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java @@ -34,8 +34,10 @@ */ package java.util.concurrent; -import java.util.concurrent.atomic.*; -import java.util.concurrent.locks.*; +import static java.util.concurrent.TimeUnit.NANOSECONDS; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.ReentrantLock; import java.util.*; /** @@ -166,7 +168,7 @@ public class ScheduledThreadPoolExecutor * Sequence number to break scheduling ties, and in turn to * guarantee FIFO order among tied entries. */ - private static final AtomicLong sequencer = new AtomicLong(0); + private static final AtomicLong sequencer = new AtomicLong(); /** * Returns current nanosecond time. @@ -231,7 +233,7 @@ public class ScheduledThreadPoolExecutor } public long getDelay(TimeUnit unit) { - return unit.convert(time - now(), TimeUnit.NANOSECONDS); + return unit.convert(time - now(), NANOSECONDS); } public int compareTo(Delayed other) { @@ -249,8 +251,8 @@ public class ScheduledThreadPoolExecutor else return 1; } - long d = (getDelay(TimeUnit.NANOSECONDS) - - other.getDelay(TimeUnit.NANOSECONDS)); + long d = (getDelay(NANOSECONDS) - + other.getDelay(NANOSECONDS)); return (d == 0) ? 0 : ((d < 0) ? -1 : 1); } @@ -424,7 +426,7 @@ public class ScheduledThreadPoolExecutor * @throws IllegalArgumentException if {@code corePoolSize < 0} */ public ScheduledThreadPoolExecutor(int corePoolSize) { - super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, + super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue()); } @@ -441,7 +443,7 @@ public class ScheduledThreadPoolExecutor */ public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory) { - super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, + super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), threadFactory); } @@ -458,7 +460,7 @@ public class ScheduledThreadPoolExecutor */ public ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler) { - super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, + super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), handler); } @@ -479,7 +481,7 @@ public class ScheduledThreadPoolExecutor public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler) { - super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, + super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), threadFactory, handler); } @@ -508,7 +510,7 @@ public class ScheduledThreadPoolExecutor private long overflowFree(long delay) { Delayed head = (Delayed) super.getQueue().peek(); if (head != null) { - long headDelay = head.getDelay(TimeUnit.NANOSECONDS); + long headDelay = head.getDelay(NANOSECONDS); if (headDelay < 0 && (delay - headDelay < 0)) delay = Long.MAX_VALUE + headDelay; } @@ -616,7 +618,7 @@ public class ScheduledThreadPoolExecutor * @throws NullPointerException {@inheritDoc} */ public void execute(Runnable command) { - schedule(command, 0, TimeUnit.NANOSECONDS); + schedule(command, 0, NANOSECONDS); } // Override AbstractExecutorService methods @@ -626,7 +628,7 @@ public class ScheduledThreadPoolExecutor * @throws NullPointerException {@inheritDoc} */ public Future submit(Runnable task) { - return schedule(task, 0, TimeUnit.NANOSECONDS); + return schedule(task, 0, NANOSECONDS); } /** @@ -634,8 +636,7 @@ public class ScheduledThreadPoolExecutor * @throws NullPointerException {@inheritDoc} */ public Future submit(Runnable task, T result) { - return schedule(Executors.callable(task, result), - 0, TimeUnit.NANOSECONDS); + return schedule(Executors.callable(task, result), 0, NANOSECONDS); } /** @@ -643,7 +644,7 @@ public class ScheduledThreadPoolExecutor * @throws NullPointerException {@inheritDoc} */ public Future submit(Callable task) { - return schedule(task, 0, TimeUnit.NANOSECONDS); + return schedule(task, 0, NANOSECONDS); } /** @@ -831,8 +832,8 @@ public class ScheduledThreadPoolExecutor */ private static final int INITIAL_CAPACITY = 16; - private RunnableScheduledFuture[] queue = - new RunnableScheduledFuture[INITIAL_CAPACITY]; + private RunnableScheduledFuture[] queue = + new RunnableScheduledFuture[INITIAL_CAPACITY]; private final ReentrantLock lock = new ReentrantLock(); private int size = 0; @@ -863,7 +864,7 @@ public class ScheduledThreadPoolExecutor /** * Set f's heapIndex if it is a ScheduledFutureTask. */ - private void setIndex(RunnableScheduledFuture f, int idx) { + private void setIndex(RunnableScheduledFuture f, int idx) { if (f instanceof ScheduledFutureTask) ((ScheduledFutureTask)f).heapIndex = idx; } @@ -872,10 +873,10 @@ public class ScheduledThreadPoolExecutor * Sift element added at bottom up to its heap-ordered spot. * Call only when holding lock. */ - private void siftUp(int k, RunnableScheduledFuture key) { + private void siftUp(int k, RunnableScheduledFuture key) { while (k > 0) { int parent = (k - 1) >>> 1; - RunnableScheduledFuture e = queue[parent]; + RunnableScheduledFuture e = queue[parent]; if (key.compareTo(e) >= 0) break; queue[k] = e; @@ -890,11 +891,11 @@ public class ScheduledThreadPoolExecutor * Sift element added at top down to its heap-ordered spot. * Call only when holding lock. */ - private void siftDown(int k, RunnableScheduledFuture key) { + private void siftDown(int k, RunnableScheduledFuture key) { int half = size >>> 1; while (k < half) { int child = (k << 1) + 1; - RunnableScheduledFuture c = queue[child]; + RunnableScheduledFuture c = queue[child]; int right = child + 1; if (right < size && c.compareTo(queue[right]) > 0) c = queue[child = right]; @@ -959,7 +960,7 @@ public class ScheduledThreadPoolExecutor setIndex(queue[i], -1); int s = --size; - RunnableScheduledFuture replacement = queue[s]; + RunnableScheduledFuture replacement = queue[s]; queue[s] = null; if (s != i) { siftDown(i, replacement); @@ -990,7 +991,7 @@ public class ScheduledThreadPoolExecutor return Integer.MAX_VALUE; } - public RunnableScheduledFuture peek() { + public RunnableScheduledFuture peek() { final ReentrantLock lock = this.lock; lock.lock(); try { @@ -1003,7 +1004,7 @@ public class ScheduledThreadPoolExecutor public boolean offer(Runnable x) { if (x == null) throw new NullPointerException(); - RunnableScheduledFuture e = (RunnableScheduledFuture)x; + RunnableScheduledFuture e = (RunnableScheduledFuture)x; final ReentrantLock lock = this.lock; lock.lock(); try { @@ -1045,9 +1046,9 @@ public class ScheduledThreadPoolExecutor * holding lock. * @param f the task to remove and return */ - private RunnableScheduledFuture finishPoll(RunnableScheduledFuture f) { + private RunnableScheduledFuture finishPoll(RunnableScheduledFuture f) { int s = --size; - RunnableScheduledFuture x = queue[s]; + RunnableScheduledFuture x = queue[s]; queue[s] = null; if (s != 0) siftDown(0, x); @@ -1055,12 +1056,12 @@ public class ScheduledThreadPoolExecutor return f; } - public RunnableScheduledFuture poll() { + public RunnableScheduledFuture poll() { final ReentrantLock lock = this.lock; lock.lock(); try { - RunnableScheduledFuture first = queue[0]; - if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0) + RunnableScheduledFuture first = queue[0]; + if (first == null || first.getDelay(NANOSECONDS) > 0) return null; else return finishPoll(first); @@ -1069,16 +1070,16 @@ public class ScheduledThreadPoolExecutor } } - public RunnableScheduledFuture take() throws InterruptedException { + public RunnableScheduledFuture take() throws InterruptedException { final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { for (;;) { - RunnableScheduledFuture first = queue[0]; + RunnableScheduledFuture first = queue[0]; if (first == null) available.await(); else { - long delay = first.getDelay(TimeUnit.NANOSECONDS); + long delay = first.getDelay(NANOSECONDS); if (delay <= 0) return finishPoll(first); else if (leader != null) @@ -1102,21 +1103,21 @@ public class ScheduledThreadPoolExecutor } } - public RunnableScheduledFuture poll(long timeout, TimeUnit unit) + public RunnableScheduledFuture poll(long timeout, TimeUnit unit) throws InterruptedException { long nanos = unit.toNanos(timeout); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { for (;;) { - RunnableScheduledFuture first = queue[0]; + RunnableScheduledFuture first = queue[0]; if (first == null) { if (nanos <= 0) return null; else nanos = available.awaitNanos(nanos); } else { - long delay = first.getDelay(TimeUnit.NANOSECONDS); + long delay = first.getDelay(NANOSECONDS); if (delay <= 0) return finishPoll(first); if (nanos <= 0) @@ -1148,7 +1149,7 @@ public class ScheduledThreadPoolExecutor lock.lock(); try { for (int i = 0; i < size; i++) { - RunnableScheduledFuture t = queue[i]; + RunnableScheduledFuture t = queue[i]; if (t != null) { queue[i] = null; setIndex(t, -1); @@ -1164,9 +1165,10 @@ public class ScheduledThreadPoolExecutor * Return and remove first element only if it is expired. * Used only by drainTo. Call only when holding lock. */ - private RunnableScheduledFuture pollExpired() { - RunnableScheduledFuture first = queue[0]; - if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0) + private RunnableScheduledFuture pollExpired() { + // assert lock.isHeldByCurrentThread(); + RunnableScheduledFuture first = queue[0]; + if (first == null || first.getDelay(NANOSECONDS) > 0) return null; return finishPoll(first); } @@ -1179,7 +1181,7 @@ public class ScheduledThreadPoolExecutor final ReentrantLock lock = this.lock; lock.lock(); try { - RunnableScheduledFuture first; + RunnableScheduledFuture first; int n = 0; while ((first = pollExpired()) != null) { c.add(first); @@ -1201,7 +1203,7 @@ public class ScheduledThreadPoolExecutor final ReentrantLock lock = this.lock; lock.lock(); try { - RunnableScheduledFuture first; + RunnableScheduledFuture first; int n = 0; while (n < maxElements && (first = pollExpired()) != null) { c.add(first); diff --git a/jdk/src/share/classes/java/util/concurrent/SynchronousQueue.java b/jdk/src/share/classes/java/util/concurrent/SynchronousQueue.java index a1fa8e21af6..9d0d830c265 100644 --- a/jdk/src/share/classes/java/util/concurrent/SynchronousQueue.java +++ b/jdk/src/share/classes/java/util/concurrent/SynchronousQueue.java @@ -36,7 +36,6 @@ package java.util.concurrent; import java.util.concurrent.locks.*; -import java.util.concurrent.atomic.*; import java.util.*; /** @@ -163,7 +162,7 @@ public class SynchronousQueue extends AbstractQueue /** * Shared internal API for dual stacks and queues. */ - abstract static class Transferer { + abstract static class Transferer { /** * Performs a put or take. * @@ -177,7 +176,7 @@ public class SynchronousQueue extends AbstractQueue * the caller can distinguish which of these occurred * by checking Thread.interrupted. */ - abstract Object transfer(Object e, boolean timed, long nanos); + abstract E transfer(E e, boolean timed, long nanos); } /** The number of CPUs, for spin control */ @@ -206,7 +205,7 @@ public class SynchronousQueue extends AbstractQueue static final long spinForTimeoutThreshold = 1000L; /** Dual stack */ - static final class TransferStack extends Transferer { + static final class TransferStack extends Transferer { /* * This extends Scherer-Scott dual stack algorithm, differing, * among other ways, by using "covering" nodes rather than @@ -286,7 +285,7 @@ public class SynchronousQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = SNode.class; + Class k = SNode.class; matchOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("match")); nextOffset = UNSAFE.objectFieldOffset @@ -322,7 +321,8 @@ public class SynchronousQueue extends AbstractQueue /** * Puts or takes an item. */ - Object transfer(Object e, boolean timed, long nanos) { + @SuppressWarnings("unchecked") + E transfer(E e, boolean timed, long nanos) { /* * Basic algorithm is to loop trying one of three actions: * @@ -363,7 +363,7 @@ public class SynchronousQueue extends AbstractQueue } if ((h = head) != null && h.next == s) casHead(h, s.next); // help s's fulfiller - return (mode == REQUEST) ? m.item : s.item; + return (E) ((mode == REQUEST) ? m.item : s.item); } } else if (!isFulfilling(h.mode)) { // try to fulfill if (h.isCancelled()) // already cancelled @@ -379,7 +379,7 @@ public class SynchronousQueue extends AbstractQueue SNode mn = m.next; if (m.tryMatch(s)) { casHead(s, mn); // pop both s and m - return (mode == REQUEST) ? m.item : s.item; + return (E) ((mode == REQUEST) ? m.item : s.item); } else // lost match s.casNext(m, mn); // help unlink } @@ -513,7 +513,7 @@ public class SynchronousQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = TransferStack.class; + Class k = TransferStack.class; headOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("head")); } catch (Exception e) { @@ -523,7 +523,7 @@ public class SynchronousQueue extends AbstractQueue } /** Dual Queue */ - static final class TransferQueue extends Transferer { + static final class TransferQueue extends Transferer { /* * This extends Scherer-Scott dual queue algorithm, differing, * among other ways, by using modes within nodes rather than @@ -583,7 +583,7 @@ public class SynchronousQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = QNode.class; + Class k = QNode.class; itemOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("item")); nextOffset = UNSAFE.objectFieldOffset @@ -640,7 +640,8 @@ public class SynchronousQueue extends AbstractQueue /** * Puts or takes an item. */ - Object transfer(Object e, boolean timed, long nanos) { + @SuppressWarnings("unchecked") + E transfer(E e, boolean timed, long nanos) { /* Basic algorithm is to loop trying to take either of * two actions: * @@ -703,7 +704,7 @@ public class SynchronousQueue extends AbstractQueue s.item = s; s.waiter = null; } - return (x != null) ? x : e; + return (x != null) ? (E)x : e; } else { // complementary-mode QNode m = h.next; // node to fulfill @@ -720,7 +721,7 @@ public class SynchronousQueue extends AbstractQueue advanceHead(h, m); // successfully fulfilled LockSupport.unpark(m.waiter); - return (x != null) ? x : e; + return (x != null) ? (E)x : e; } } } @@ -734,7 +735,7 @@ public class SynchronousQueue extends AbstractQueue * @param nanos timeout value * @return matched item, or s if cancelled */ - Object awaitFulfill(QNode s, Object e, boolean timed, long nanos) { + Object awaitFulfill(QNode s, E e, boolean timed, long nanos) { /* Same idea as TransferStack.awaitFulfill */ long lastTime = timed ? System.nanoTime() : 0; Thread w = Thread.currentThread(); @@ -827,7 +828,7 @@ public class SynchronousQueue extends AbstractQueue static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); - Class k = TransferQueue.class; + Class k = TransferQueue.class; headOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("head")); tailOffset = UNSAFE.objectFieldOffset @@ -847,7 +848,7 @@ public class SynchronousQueue extends AbstractQueue * isn't a noticeable performance penalty for using volatile * instead of final here. */ - private transient volatile Transferer transferer; + private transient volatile Transferer transferer; /** * Creates a SynchronousQueue with nonfair access policy. @@ -863,7 +864,7 @@ public class SynchronousQueue extends AbstractQueue * access; otherwise the order is unspecified. */ public SynchronousQueue(boolean fair) { - transferer = fair ? new TransferQueue() : new TransferStack(); + transferer = fair ? new TransferQueue() : new TransferStack(); } /** @@ -922,9 +923,9 @@ public class SynchronousQueue extends AbstractQueue * @throws InterruptedException {@inheritDoc} */ public E take() throws InterruptedException { - Object e = transferer.transfer(null, false, 0); + E e = transferer.transfer(null, false, 0); if (e != null) - return (E)e; + return e; Thread.interrupted(); throw new InterruptedException(); } @@ -939,9 +940,9 @@ public class SynchronousQueue extends AbstractQueue * @throws InterruptedException {@inheritDoc} */ public E poll(long timeout, TimeUnit unit) throws InterruptedException { - Object e = transferer.transfer(null, true, unit.toNanos(timeout)); + E e = transferer.transfer(null, true, unit.toNanos(timeout)); if (e != null || !Thread.interrupted()) - return (E)e; + return e; throw new InterruptedException(); } @@ -953,7 +954,7 @@ public class SynchronousQueue extends AbstractQueue * element is available. */ public E poll() { - return (E)transferer.transfer(null, true, 0); + return transferer.transfer(null, true, 0); } /** @@ -1065,8 +1066,19 @@ public class SynchronousQueue extends AbstractQueue * * @return an empty iterator */ + @SuppressWarnings("unchecked") public Iterator iterator() { - return Collections.emptyIterator(); + return (Iterator) EmptyIterator.EMPTY_ITERATOR; + } + + // Replicated from a previous version of Collections + private static class EmptyIterator implements Iterator { + static final EmptyIterator EMPTY_ITERATOR + = new EmptyIterator(); + + public boolean hasNext() { return false; } + public E next() { throw new NoSuchElementException(); } + public void remove() { throw new IllegalStateException(); } } /** @@ -1103,8 +1115,7 @@ public class SynchronousQueue extends AbstractQueue if (c == this) throw new IllegalArgumentException(); int n = 0; - E e; - while ( (e = poll()) != null) { + for (E e; (e = poll()) != null;) { c.add(e); ++n; } @@ -1123,8 +1134,7 @@ public class SynchronousQueue extends AbstractQueue if (c == this) throw new IllegalArgumentException(); int n = 0; - E e; - while (n < maxElements && (e = poll()) != null) { + for (E e; n < maxElements && (e = poll()) != null;) { c.add(e); ++n; } @@ -1139,6 +1149,7 @@ public class SynchronousQueue extends AbstractQueue * object is ever serialized or deserialized. */ + @SuppressWarnings("serial") static class WaitQueue implements java.io.Serializable { } static class LifoWaitQueue extends WaitQueue { private static final long serialVersionUID = -3633113410248163686L; @@ -1151,7 +1162,7 @@ public class SynchronousQueue extends AbstractQueue private WaitQueue waitingConsumers; /** - * Save the state to a stream (that is, serialize it). + * Saves the state to a stream (that is, serializes it). * * @param s the stream */ @@ -1175,9 +1186,9 @@ public class SynchronousQueue extends AbstractQueue throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); if (waitingProducers instanceof FifoWaitQueue) - transferer = new TransferQueue(); + transferer = new TransferQueue(); else - transferer = new TransferStack(); + transferer = new TransferStack(); } // Unsafe mechanics diff --git a/jdk/test/java/util/Collections/EmptyIterator.java b/jdk/test/java/util/Collections/EmptyIterator.java index a2b2f41742c..902f03407dc 100644 --- a/jdk/test/java/util/Collections/EmptyIterator.java +++ b/jdk/test/java/util/Collections/EmptyIterator.java @@ -35,8 +35,6 @@ public class EmptyIterator { void test(String[] args) throws Throwable { testEmptyCollection(Collections.emptyList()); testEmptyCollection(Collections.emptySet()); - testEmptyCollection(new java.util.concurrent. - SynchronousQueue()); testEmptyMap(Collections.emptyMap());