stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

7118066: Warnings in java.util.concurrent package

Browse Source 
Reviewed-by: chegar, dholmes
This commit is contained in:
Doug Lea 2011-12-12 10:45:54 +00:00
parent 6d0e8939c1
commit 87062ca29f
18 changed files with 242 additions and 217 deletions

14
jdk/src/share/classes/java/util/concurrent/ArrayBlockingQueue.java

@ -131,8 +131,9 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
/**
* Returns item at index i.
*/
@SuppressWarnings("unchecked")
final E itemAt(int i) {
return this.<E>cast(items[i]);
return (E) items[i];
}
/**
@ -162,7 +163,8 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
*/
private E extract() {
final Object[] items = this.items;
E x = this.<E>cast(items[takeIndex]);
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = null;
takeIndex = inc(takeIndex);
--count;
@ -647,7 +649,9 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
int n = 0;
int max = count;
while (n < max) {
c.add(this.<E>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<E> extends AbstractQueue<E>
int n = 0;
int max = (maxElements < count) ? maxElements : count;
while (n < max) {
c.add(this.<E>cast(items[i]));
@SuppressWarnings("unchecked")
E x = (E) items[i];
c.add(x);
items[i] = null;
i = inc(i);
++n;

45
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<K, V> extends AbstractMap<K, V>
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<K, V> extends AbstractMap<K, V>
int newCapacity = oldCapacity << 1;
threshold = (int)(newCapacity * loadFactor);
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
(HashEntry<K,V>[]) new HashEntry<?,?>[newCapacity];
int sizeMask = newCapacity - 1;
for (int i = 0; i < oldCapacity ; i++) {
HashEntry<K,V> e = oldTable[i];
@ -677,7 +674,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
int cap = proto.table.length;
float lf = proto.loadFactor;
int threshold = (int)(cap * lf);
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry<?,?>[cap];
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) { // recheck
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
@ -694,7 +691,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
// 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<K,V> segmentForHash(int h) {
@ -703,7 +700,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
}
/**
* 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 <K,V> HashEntry<K,V> entryForHash(Segment<K,V> seg, int h) {
@ -758,8 +755,8 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
// create segments and segments[0]
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
(HashEntry<K,V>[])new HashEntry<?,?>[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment<?,?>[ssize];
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
@ -916,6 +913,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
*
* @throws NullPointerException if the specified key is null
*/
@SuppressWarnings("unchecked")
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
@ -1026,7 +1024,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
* 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 <tt>true</tt> if and only if some key maps to the
* <tt>value</tt> argument in this table as
@ -1262,7 +1260,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
}
/**
* 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<K, V> extends AbstractMap<K, V>
final class WriteThroughEntry
extends AbstractMap.SimpleEntry<K,V>
{
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<K, V> extends AbstractMap<K, V>
/* ---------------- Serialization Support -------------- */
/**
* Save the state of the <tt>ConcurrentHashMap</tt> instance to a
* stream (i.e., serialize it).
* Saves the state of the <tt>ConcurrentHashMap</tt> 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<K, V> extends AbstractMap<K, V>
}
/**
* Reconstitute the <tt>ConcurrentHashMap</tt> instance from a
* stream (i.e., deserialize it).
* Reconstitutes the <tt>ConcurrentHashMap</tt> 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<K, V> extends AbstractMap<K, V>
Segment<K,V> seg = segments[k];
if (seg != null) {
seg.threshold = (int)(cap * seg.loadFactor);
seg.table = (HashEntry<K,V>[]) new HashEntry[cap];
seg.table = (HashEntry<K,V>[]) new HashEntry<?,?>[cap];
}
}
@ -1504,8 +1505,8 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
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);

4
jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java

@ -335,7 +335,7 @@ public class ConcurrentLinkedDeque<E>
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<E>
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

4
jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java

@ -208,7 +208,7 @@ public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = ConcurrentLinkedQueue.class;
Class<?> k = ConcurrentLinkedQueue.class;
headOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("head"));
tailOffset = UNSAFE.objectFieldOffset

126
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 <V> the type of mapped values
* @since 1.6
*/
@SuppressWarnings("unchecked")
public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
implements ConcurrentNavigableMap<K,V>,
Cloneable,
@ -352,11 +352,11 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
private transient int randomSeed;
/** Lazily initialized key set */
private transient KeySet keySet;
private transient KeySet<K> keySet;
/** Lazily initialized entry set */
private transient EntrySet entrySet;
private transient EntrySet<K,V> entrySet;
/** Lazily initialized values collection */
private transient Values values;
private transient Values<V> values;
/** Lazily initialized descending key set */
private transient ConcurrentNavigableMap<K,V> descendingMap;
@ -517,7 +517,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
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<K,V> extends AbstractMap<K,V>
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<K,V> extends AbstractMap<K,V>
* direction.
*/
level = max + 1;
Index<K,V>[] idxs = (Index<K,V>[])new Index[level+1];
Index<K,V>[] idxs = (Index<K,V>[])new Index<?,?>[level+1];
Index<K,V> idx = null;
for (int i = 1; i <= level; ++i)
idxs[i] = idx = new Index<K,V>(z, idx, null);
@ -1436,16 +1436,16 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
* @return a shallow copy of this map
*/
public ConcurrentSkipListMap<K,V> clone() {
ConcurrentSkipListMap<K,V> clone = null;
try {
clone = (ConcurrentSkipListMap<K,V>) super.clone();
@SuppressWarnings("unchecked")
ConcurrentSkipListMap<K,V> clone =
(ConcurrentSkipListMap<K,V>) 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<K,V> extends AbstractMap<K,V>
/* ---------------- 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<K,V> extends AbstractMap<K,V>
}
/**
* 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<K,V> extends AbstractMap<K,V>
* @return a navigable set view of the keys in this map
*/
public NavigableSet<K> keySet() {
KeySet ks = keySet;
return (ks != null) ? ks : (keySet = new KeySet(this));
KeySet<K> ks = keySet;
return (ks != null) ? ks : (keySet = new KeySet<K>(this));
}
public NavigableSet<K> navigableKeySet() {
KeySet ks = keySet;
return (ks != null) ? ks : (keySet = new KeySet(this));
KeySet<K> ks = keySet;
return (ks != null) ? ks : (keySet = new KeySet<K>(this));
}
/**
@ -1783,8 +1785,8 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
* reflect any modifications subsequent to construction.
*/
public Collection<V> values() {
Values vs = values;
return (vs != null) ? vs : (values = new Values(this));
Values<V> vs = values;
return (vs != null) ? vs : (values = new Values<V>(this));
}
/**
@ -1812,8 +1814,8 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
* sorted in ascending key order
*/
public Set<Map.Entry<K,V>> entrySet() {
EntrySet es = entrySet;
return (es != null) ? es : (entrySet = new EntrySet(this));
EntrySet<K,V> es = entrySet;
return (es != null) ? es : (entrySet = new EntrySet<K,V>(this));
}
public ConcurrentNavigableMap<K,V> descendingMap() {
@ -2304,8 +2306,8 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
static final class KeySet<E>
extends AbstractSet<E> implements NavigableSet<E> {
private final ConcurrentNavigableMap<E,Object> m;
KeySet(ConcurrentNavigableMap<E,Object> map) { m = map; }
private final ConcurrentNavigableMap<E,?> m;
KeySet(ConcurrentNavigableMap<E,?> 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<K,V> extends AbstractMap<K,V>
public E first() { return m.firstKey(); }
public E last() { return m.lastKey(); }
public E pollFirst() {
Map.Entry<E,Object> e = m.pollFirstEntry();
Map.Entry<E,?> e = m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}
public E pollLast() {
Map.Entry<E,Object> e = m.pollLastEntry();
Map.Entry<E,?> e = m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
public Iterator<E> iterator() {
@ -2374,20 +2376,20 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
return tailSet(fromElement, true);
}
public NavigableSet<E> descendingSet() {
return new KeySet(m.descendingMap());
return new KeySet<E>(m.descendingMap());
}
}
static final class Values<E> extends AbstractCollection<E> {
private final ConcurrentNavigableMap<Object, E> m;
Values(ConcurrentNavigableMap<Object, E> map) {
private final ConcurrentNavigableMap<?, E> m;
Values(ConcurrentNavigableMap<?, E> map) {
m = map;
}
public Iterator<E> iterator() {
if (m instanceof ConcurrentSkipListMap)
return ((ConcurrentSkipListMap<Object,E>)m).valueIterator();
return ((ConcurrentSkipListMap<?,E>)m).valueIterator();
else
return ((SubMap<Object,E>)m).valueIterator();
return ((SubMap<?,E>)m).valueIterator();
}
public boolean isEmpty() {
return m.isEmpty();
@ -2421,14 +2423,14 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<K1,V1> e = (Map.Entry<K1,V1>)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<K1,V1> e = (Map.Entry<K1,V1>)o;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return m.remove(e.getKey(),
e.getValue());
}
@ -2568,9 +2570,9 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
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<K,V> extends AbstractMap<K,V>
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<K,V> extends AbstractMap<K,V>
*/
private Map.Entry<K,V> 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<K,V> n = m.findNear(key, rel);
if (n == null || !inBounds(n.key))
@ -2688,13 +2690,13 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
// 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<K,V> n = loNode();
if (isBeforeEnd(n))
return n.key;
@ -2702,7 +2704,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
return null;
}
if (tooHigh(key)) {
if ((rel & m.LT) != 0) {
if ((rel & LT) != 0) {
ConcurrentSkipListMap.Node<K,V> n = hiNode();
if (n != null) {
K last = n.key;
@ -2734,7 +2736,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
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<K,V> extends AbstractMap<K,V>
/* ---------------- Relational methods -------------- */
public Map.Entry<K,V> 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<K,V> 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<K,V> 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<K,V> 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<K,V> extends AbstractMap<K,V>
public NavigableSet<K> keySet() {
KeySet<K> ks = keySetView;
return (ks != null) ? ks : (keySetView = new KeySet(this));
return (ks != null) ? ks : (keySetView = new KeySet<K>(this));
}
public NavigableSet<K> navigableKeySet() {
KeySet<K> ks = keySetView;
return (ks != null) ? ks : (keySetView = new KeySet(this));
return (ks != null) ? ks : (keySetView = new KeySet<K>(this));
}
public Collection<V> values() {
Collection<V> vs = valuesView;
return (vs != null) ? vs : (valuesView = new Values(this));
return (vs != null) ? vs : (valuesView = new Values<V>(this));
}
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es = entrySetView;
return (es != null) ? es : (entrySetView = new EntrySet(this));
return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this));
}
public NavigableSet<K> descendingKeySet() {
@ -3109,7 +3111,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = ConcurrentSkipListMap.class;
Class<?> k = ConcurrentSkipListMap.class;
headOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("head"));
} catch (Exception e) {

19
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<E>
* @return a shallow copy of this set
*/
public ConcurrentSkipListSet<E> clone() {
ConcurrentSkipListSet<E> clone = null;
try {
clone = (ConcurrentSkipListSet<E>) super.clone();
clone.setMap(new ConcurrentSkipListMap(m));
@SuppressWarnings("unchecked")
ConcurrentSkipListSet<E> clone =
(ConcurrentSkipListSet<E>) super.clone();
clone.setMap(new ConcurrentSkipListMap<E,Object>(m));
return clone;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
return clone;
}
/* ---------------- Set operations -------------- */
@ -322,8 +321,8 @@ public class ConcurrentSkipListSet<E>
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<E>
* @return a reverse order view of this set
*/
public NavigableSet<E> descendingSet() {
return new ConcurrentSkipListSet(m.descendingMap());
return new ConcurrentSkipListSet<E>(m.descendingMap());
}
// Support for resetting map in clone
@ -481,7 +480,7 @@ public class ConcurrentSkipListSet<E>
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = ConcurrentSkipListSet.class;
Class<?> k = ConcurrentSkipListSet.class;
mapOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("m"));
} catch (Exception e) {

11
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<E>
*/
public Object clone() {
try {
CopyOnWriteArrayList c = (CopyOnWriteArrayList)(super.clone());
c.resetLock();
return c;
@SuppressWarnings("unchecked")
CopyOnWriteArrayList<E> clone =
(CopyOnWriteArrayList<E>) 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<E>
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = CopyOnWriteArrayList.class;
Class<?> k = CopyOnWriteArrayList.class;
lockOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("lock"));
} catch (Exception e) {

2
jdk/src/share/classes/java/util/concurrent/DelayQueue.java

@ -531,7 +531,7 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
// not just a .equals element.
lock.lock();
try {
for (Iterator it = q.iterator(); it.hasNext(); ) {
for (Iterator<E> it = q.iterator(); it.hasNext(); ) {
if (it.next() == x) {
it.remove();
return;

20
jdk/src/share/classes/java/util/concurrent/Exchanger.java

@ -279,6 +279,7 @@ public class Exchanger<V> {
* 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<Object> {
/** The element offered by the Thread creating this node. */
public final Object item;
@ -303,6 +304,7 @@ public class Exchanger<V> {
* would improve throughput more than enough to outweigh using
* extra space.
*/
@SuppressWarnings("serial")
private static final class Slot extends AtomicReference<Object> {
// 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<V> {
* @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<V> {
* @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();
}

4
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) {

2
jdk/src/share/classes/java/util/concurrent/ForkJoinTask.java

@ -520,7 +520,7 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
if (e == null || (ex = e.ex) == null)
return null;
if (e.thrower != Thread.currentThread().getId()) {
Class ec = ex.getClass();
Class<? extends Throwable> ec = ex.getClass();
try {
Constructor<?> noArgCtor = null;
Constructor<?>[] cs = ec.getConstructors();// public ctors only

8
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) {

30
jdk/src/share/classes/java/util/concurrent/LinkedTransferQueue.java

@ -330,8 +330,8 @@ public class LinkedTransferQueue<E> extends AbstractQueue<E>
* 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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
break; // unless slack < 2
}
LockSupport.unpark(p.waiter);
return this.<E>cast(item);
return LinkedTransferQueue.<E>cast(item);
}
}
Node n = p.next;
@ -705,7 +705,7 @@ public class LinkedTransferQueue<E> extends AbstractQueue<E>
if (item != e) { // matched
// assert item != s;
s.forgetContents(); // avoid garbage
return this.<E>cast(item);
return LinkedTransferQueue.<E>cast(item);
}
if ((w.isInterrupted() || (timed && nanos <= 0)) &&
s.casItem(e, s)) { // cancel
@ -786,7 +786,7 @@ public class LinkedTransferQueue<E> extends AbstractQueue<E>
Object item = p.item;
if (p.isData) {
if (item != null && item != p)
return this.<E>cast(item);
return LinkedTransferQueue.<E>cast(item);
}
else if (item == null)
return null;
@ -1008,7 +1008,6 @@ public class LinkedTransferQueue<E> extends AbstractQueue<E>
return false;
}
/**
* Creates an initially empty {@code LinkedTransferQueue}.
*/
@ -1045,7 +1044,8 @@ public class LinkedTransferQueue<E> extends AbstractQueue<E>
* 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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
* {@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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = LinkedTransferQueue.class;
Class<?> k = LinkedTransferQueue.class;
headOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("head"));
tailOffset = UNSAFE.objectFieldOffset

2
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) {

5
jdk/src/share/classes/java/util/concurrent/PriorityBlockingQueue.java

@ -94,6 +94,7 @@ import java.util.*;
* @author Doug Lea
* @param <E> the type of elements held in this collection
*/
@SuppressWarnings("unchecked")
public class PriorityBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
private static final long serialVersionUID = 5595510919245408276L;
@ -168,7 +169,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
* to maintain compatibility with previous versions
* of this class. Non-null only during serialization/deserialization.
*/
private PriorityQueue q;
private PriorityQueue<E> q;
/**
* Creates a {@code PriorityBlockingQueue} with the default
@ -968,7 +969,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = PriorityBlockingQueue.class;
Class<?> k = PriorityBlockingQueue.class;
allocationSpinLockOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("allocationSpinLock"));
} catch (Exception e) {

88
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 <T> Future<T> 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 <T> Future<T> submit(Callable<T> 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);

73
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<E> extends AbstractQueue<E>
/**
* Shared internal API for dual stacks and queues.
*/
abstract static class Transferer {
abstract static class Transferer<E> {
/**
* Performs a put or take.
*
@ -177,7 +176,7 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
* 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<E> extends AbstractQueue<E>
static final long spinForTimeoutThreshold = 1000L;
/** Dual stack */
static final class TransferStack extends Transferer {
static final class TransferStack<E> extends Transferer<E> {
/*
* This extends Scherer-Scott dual stack algorithm, differing,
* among other ways, by using "covering" nodes rather than
@ -286,7 +285,7 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
/**
* 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<E> extends AbstractQueue<E>
}
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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
}
/** Dual Queue */
static final class TransferQueue extends Transferer {
static final class TransferQueue<E> extends Transferer<E> {
/*
* 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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
/**
* 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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
* @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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
* isn't a noticeable performance penalty for using volatile
* instead of final here.
*/
private transient volatile Transferer transferer;
private transient volatile Transferer<E> transferer;
/**
* Creates a <tt>SynchronousQueue</tt> with nonfair access policy.
@ -863,7 +864,7 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
* access; otherwise the order is unspecified.
*/
public SynchronousQueue(boolean fair) {
transferer = fair ? new TransferQueue() : new TransferStack();
transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
}
/**
@ -922,9 +923,9 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
* @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<E> extends AbstractQueue<E>
* @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<E> extends AbstractQueue<E>
* 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<E> extends AbstractQueue<E>
*
* @return an empty iterator
*/
@SuppressWarnings("unchecked")
public Iterator<E> iterator() {
return Collections.emptyIterator();
return (Iterator<E>) EmptyIterator.EMPTY_ITERATOR;
}
// Replicated from a previous version of Collections
private static class EmptyIterator<E> implements Iterator<E> {
static final EmptyIterator<Object> EMPTY_ITERATOR
= new EmptyIterator<Object>();
public boolean hasNext() { return false; }
public E next() { throw new NoSuchElementException(); }
public void remove() { throw new IllegalStateException(); }
}
/**
@ -1103,8 +1115,7 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
* 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<E> extends AbstractQueue<E>
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<E> extends AbstractQueue<E>
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
if (waitingProducers instanceof FifoWaitQueue)
transferer = new TransferQueue();
transferer = new TransferQueue<E>();
else
transferer = new TransferStack();
transferer = new TransferStack<E>();
}
// Unsafe mechanics

2
jdk/test/java/util/Collections/EmptyIterator.java

@ -35,8 +35,6 @@ public class EmptyIterator {
void test(String[] args) throws Throwable {
testEmptyCollection(Collections.<Object>emptyList());
testEmptyCollection(Collections.<Object>emptySet());
testEmptyCollection(new java.util.concurrent.
SynchronousQueue<Object>());
testEmptyMap(Collections.<Object, Object>emptyMap());