8001575: Minor/sync/cleanup j.u.c with Dougs CVS - Oct 2012
Reviewed-by: chegar, dholmes
--- a/jdk/src/share/classes/java/util/concurrent/AbstractExecutorService.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/AbstractExecutorService.java Fri Oct 26 21:34:24 2012 +0100
@@ -137,7 +137,7 @@
* the main mechanics of invokeAny.
*/
private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
- boolean timed, long nanos)
+ boolean timed, long nanos)
throws InterruptedException, ExecutionException, TimeoutException {
if (tasks == null)
throw new NullPointerException();
@@ -158,7 +158,7 @@
// Record exceptions so that if we fail to obtain any
// result, we can throw the last exception we got.
ExecutionException ee = null;
- long lastTime = timed ? System.nanoTime() : 0;
+ final long deadline = timed ? System.nanoTime() + nanos : 0L;
Iterator<? extends Callable<T>> it = tasks.iterator();
// Start one task for sure; the rest incrementally
@@ -180,9 +180,7 @@
f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
if (f == null)
throw new TimeoutException();
- long now = System.nanoTime();
- nanos -= now - lastTime;
- lastTime = now;
+ nanos = deadline - System.nanoTime();
}
else
f = ecs.take();
@@ -258,7 +256,7 @@
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException {
- if (tasks == null || unit == null)
+ if (tasks == null)
throw new NullPointerException();
long nanos = unit.toNanos(timeout);
List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
@@ -267,23 +265,21 @@
for (Callable<T> t : tasks)
futures.add(newTaskFor(t));
- long lastTime = System.nanoTime();
+ final long deadline = System.nanoTime() + nanos;
// Interleave time checks and calls to execute in case
// executor doesn't have any/much parallelism.
Iterator<Future<T>> it = futures.iterator();
while (it.hasNext()) {
execute((Runnable)(it.next()));
- long now = System.nanoTime();
- nanos -= now - lastTime;
- lastTime = now;
- if (nanos <= 0)
+ nanos = deadline - System.nanoTime();
+ if (nanos <= 0L)
return futures;
}
for (Future<T> f : futures) {
if (!f.isDone()) {
- if (nanos <= 0)
+ if (nanos <= 0L)
return futures;
try {
f.get(nanos, TimeUnit.NANOSECONDS);
@@ -292,9 +288,7 @@
} catch (TimeoutException toe) {
return futures;
}
- long now = System.nanoTime();
- nanos -= now - lastTime;
- lastTime = now;
+ nanos = deadline - System.nanoTime();
}
}
done = true;
--- a/jdk/src/share/classes/java/util/concurrent/BlockingQueue.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/BlockingQueue.java Fri Oct 26 21:34:24 2012 +0100
@@ -127,7 +127,7 @@
* Usage example, based on a typical producer-consumer scenario.
* Note that a <tt>BlockingQueue</tt> can safely be used with multiple
* producers and multiple consumers.
- * <pre>
+ * <pre> {@code
* class Producer implements Runnable {
* private final BlockingQueue queue;
* Producer(BlockingQueue q) { queue = q; }
@@ -160,8 +160,7 @@
* new Thread(c1).start();
* new Thread(c2).start();
* }
- * }
- * </pre>
+ * }}</pre>
*
* <p>Memory consistency effects: As with other concurrent
* collections, actions in a thread prior to placing an object into a
--- a/jdk/src/share/classes/java/util/concurrent/BrokenBarrierException.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/BrokenBarrierException.java Fri Oct 26 21:34:24 2012 +0100
@@ -44,7 +44,6 @@
*
* @since 1.5
* @author Doug Lea
- *
*/
public class BrokenBarrierException extends Exception {
private static final long serialVersionUID = 7117394618823254244L;
--- a/jdk/src/share/classes/java/util/concurrent/CompletionService.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/CompletionService.java Fri Oct 26 21:34:24 2012 +0100
@@ -57,7 +57,6 @@
* <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
* actions taken by that task, which in turn <i>happen-before</i>
* actions following a successful return from the corresponding {@code take()}.
- *
*/
public interface CompletionService<V> {
/**
@@ -98,7 +97,6 @@
*/
Future<V> take() throws InterruptedException;
-
/**
* Retrieves and removes the Future representing the next
* completed task or <tt>null</tt> if none are present.
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java Fri Oct 26 21:34:24 2012 +0100
@@ -90,7 +90,6 @@
* @author Martin Buchholz
* @param <E> the type of elements held in this collection
*/
-
public class ConcurrentLinkedDeque<E>
extends AbstractCollection<E>
implements Deque<E>, java.io.Serializable {
@@ -1250,8 +1249,7 @@
* The following code can be used to dump the deque into a newly
* allocated array of {@code String}:
*
- * <pre>
- * String[] y = x.toArray(new String[0]);</pre>
+ * <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
*
* Note that {@code toArray(new Object[0])} is identical in function to
* {@code toArray()}.
@@ -1388,11 +1386,10 @@
}
/**
- * Saves the state to a stream (that is, serializes it).
+ * Saves this deque to a stream (that is, serializes it).
*
* @serialData All of the elements (each an {@code E}) in
* the proper order, followed by a null
- * @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
@@ -1412,8 +1409,7 @@
}
/**
- * Reconstitutes the instance from a stream (that is, deserializes it).
- * @param s the stream
+ * Reconstitutes this deque from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
@@ -1436,7 +1432,6 @@
initHeadTail(h, t);
}
-
private boolean casHead(Node<E> cmp, Node<E> val) {
return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
}
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java Fri Oct 26 21:34:24 2012 +0100
@@ -98,7 +98,6 @@
* @since 1.5
* @author Doug Lea
* @param <E> the type of elements held in this collection
- *
*/
public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
implements Queue<E>, java.io.Serializable {
@@ -247,7 +246,6 @@
*/
private transient volatile Node<E> tail;
-
/**
* Creates a {@code ConcurrentLinkedQueue} that is initially empty.
*/
@@ -609,8 +607,7 @@
* The following code can be used to dump the queue into a newly
* allocated array of {@code String}:
*
- * <pre>
- * String[] y = x.toArray(new String[0]);</pre>
+ * <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
*
* Note that {@code toArray(new Object[0])} is identical in function to
* {@code toArray()}.
@@ -747,11 +744,10 @@
}
/**
- * Saves the state to a stream (that is, serializes it).
+ * Saves this queue to a stream (that is, serializes it).
*
* @serialData All of the elements (each an {@code E}) in
* the proper order, followed by a null
- * @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
@@ -771,8 +767,7 @@
}
/**
- * Reconstitutes the instance from a stream (that is, deserializes it).
- * @param s the stream
+ * Reconstitutes this queue from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentMap.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentMap.java Fri Oct 26 21:34:24 2012 +0100
@@ -61,11 +61,12 @@
* If the specified key is not already associated
* with a value, associate it with the given value.
* This is equivalent to
- * <pre>
- * if (!map.containsKey(key))
- * return map.put(key, value);
- * else
- * return map.get(key);</pre>
+ * <pre> {@code
+ * if (!map.containsKey(key))
+ * return map.put(key, value);
+ * else
+ * return map.get(key);}</pre>
+ *
* except that the action is performed atomically.
*
* @param key key with which the specified value is to be associated
@@ -83,18 +84,19 @@
* and this map does not permit null keys or values
* @throws IllegalArgumentException if some property of the specified key
* or value prevents it from being stored in this map
- *
*/
V putIfAbsent(K key, V value);
/**
* Removes the entry for a key only if currently mapped to a given value.
* This is equivalent to
- * <pre>
- * if (map.containsKey(key) && map.get(key).equals(value)) {
- * map.remove(key);
- * return true;
- * } else return false;</pre>
+ * <pre> {@code
+ * if (map.containsKey(key) && map.get(key).equals(value)) {
+ * map.remove(key);
+ * return true;
+ * } else
+ * return false;}</pre>
+ *
* except that the action is performed atomically.
*
* @param key key with which the specified value is associated
@@ -114,11 +116,13 @@
/**
* Replaces the entry for a key only if currently mapped to a given value.
* This is equivalent to
- * <pre>
- * if (map.containsKey(key) && map.get(key).equals(oldValue)) {
- * map.put(key, newValue);
- * return true;
- * } else return false;</pre>
+ * <pre> {@code
+ * if (map.containsKey(key) && map.get(key).equals(oldValue)) {
+ * map.put(key, newValue);
+ * return true;
+ * } else
+ * return false;}</pre>
+ *
* except that the action is performed atomically.
*
* @param key key with which the specified value is associated
@@ -139,10 +143,12 @@
/**
* Replaces the entry for a key only if currently mapped to some value.
* This is equivalent to
- * <pre>
- * if (map.containsKey(key)) {
- * return map.put(key, value);
- * } else return null;</pre>
+ * <pre> {@code
+ * if (map.containsKey(key)) {
+ * return map.put(key, value);
+ * } else
+ * return null;}</pre>
+ *
* except that the action is performed atomically.
*
* @param key key with which the specified value is associated
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentNavigableMap.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentNavigableMap.java Fri Oct 26 21:34:24 2012 +0100
@@ -67,7 +67,6 @@
*/
ConcurrentNavigableMap<K,V> headMap(K toKey, boolean inclusive);
-
/**
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java Fri Oct 26 21:34:24 2012 +0100
@@ -1507,7 +1507,7 @@
/* ---------------- Serialization -------------- */
/**
- * Saves the state of this map to a stream (that is, serializes it).
+ * Saves 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,9 +1532,7 @@
}
/**
- * Reconstitutes the map from a stream (that is, deserializes it).
- *
- * @param s the stream
+ * Reconstitutes this map from a stream (that is, deserializes it).
*/
private void readObject(final java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
@@ -2342,7 +2340,7 @@
Collection<?> c = (Collection<?>) o;
try {
return containsAll(c) && c.containsAll(this);
- } catch (ClassCastException unused) {
+ } catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
@@ -2451,7 +2449,7 @@
Collection<?> c = (Collection<?>) o;
try {
return containsAll(c) && c.containsAll(this);
- } catch (ClassCastException unused) {
+ } catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListSet.java Fri Oct 26 21:34:24 2012 +0100
@@ -298,7 +298,7 @@
Collection<?> c = (Collection<?>) o;
try {
return containsAll(c) && c.containsAll(this);
- } catch (ClassCastException unused) {
+ } catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
--- a/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java Fri Oct 26 21:34:24 2012 +0100
@@ -35,7 +35,7 @@
package java.util.concurrent;
import java.util.*;
-import java.util.concurrent.locks.*;
+import java.util.concurrent.locks.ReentrantLock;
/**
* A thread-safe variant of {@link java.util.ArrayList} in which all mutative
@@ -152,7 +152,7 @@
}
/**
- * Test for equality, coping with nulls.
+ * Tests for equality, coping with nulls.
*/
private static boolean eq(Object o1, Object o2) {
return (o1 == null ? o2 == null : o1.equals(o2));
@@ -333,8 +333,7 @@
* The following code can be used to dump the list into a newly
* allocated array of <tt>String</tt>:
*
- * <pre>
- * String[] y = x.toArray(new String[0]);</pre>
+ * <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
*
* Note that <tt>toArray(new Object[0])</tt> is identical in function to
* <tt>toArray()</tt>.
@@ -548,9 +547,9 @@
* @param fromIndex index of first element to be removed
* @param toIndex index after last element to be removed
* @throws IndexOutOfBoundsException if fromIndex or toIndex out of range
- * ({@code{fromIndex < 0 || toIndex > size() || toIndex < fromIndex})
+ * ({@code fromIndex < 0 || toIndex > size() || toIndex < fromIndex})
*/
- private void removeRange(int fromIndex, int toIndex) {
+ void removeRange(int fromIndex, int toIndex) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
@@ -576,7 +575,7 @@
}
/**
- * Append the element if not present.
+ * Appends the element, if not present.
*
* @param e element to be added to this list, if absent
* @return <tt>true</tt> if the element was added
@@ -641,6 +640,7 @@
* @see #remove(Object)
*/
public boolean removeAll(Collection<?> c) {
+ if (c == null) throw new NullPointerException();
final ReentrantLock lock = this.lock;
lock.lock();
try {
@@ -683,6 +683,7 @@
* @see #remove(Object)
*/
public boolean retainAll(Collection<?> c) {
+ if (c == null) throw new NullPointerException();
final ReentrantLock lock = this.lock;
lock.lock();
try {
@@ -837,15 +838,14 @@
}
/**
- * Saves the state of the list to a stream (that is, serializes it).
+ * Saves this list to a stream (that is, serializes it).
*
* @serialData The length of the array backing the list is emitted
* (int), followed by all of its elements (each an Object)
* in the proper order.
- * @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
- throws java.io.IOException{
+ throws java.io.IOException {
s.defaultWriteObject();
@@ -859,9 +859,7 @@
}
/**
- * Reconstitutes the list from a stream (that is, deserializes it).
- *
- * @param s the stream
+ * Reconstitutes this list from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
@@ -1266,17 +1264,14 @@
private static class COWSubListIterator<E> implements ListIterator<E> {
- private final ListIterator<E> i;
- private final int index;
+ private final ListIterator<E> it;
private final int offset;
private final int size;
- COWSubListIterator(List<E> l, int index, int offset,
- int size) {
- this.index = index;
+ COWSubListIterator(List<E> l, int index, int offset, int size) {
this.offset = offset;
this.size = size;
- i = l.listIterator(index+offset);
+ it = l.listIterator(index+offset);
}
public boolean hasNext() {
@@ -1285,7 +1280,7 @@
public E next() {
if (hasNext())
- return i.next();
+ return it.next();
else
throw new NoSuchElementException();
}
@@ -1296,17 +1291,17 @@
public E previous() {
if (hasPrevious())
- return i.previous();
+ return it.previous();
else
throw new NoSuchElementException();
}
public int nextIndex() {
- return i.nextIndex() - offset;
+ return it.nextIndex() - offset;
}
public int previousIndex() {
- return i.previousIndex() - offset;
+ return it.previousIndex() - offset;
}
public void remove() {
--- a/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArraySet.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/CopyOnWriteArraySet.java Fri Oct 26 21:34:24 2012 +0100
@@ -189,8 +189,7 @@
* The following code can be used to dump the set into a newly allocated
* array of <tt>String</tt>:
*
- * <pre>
- * String[] y = x.toArray(new String[0]);</pre>
+ * <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
*
* Note that <tt>toArray(new Object[0])</tt> is identical in function to
* <tt>toArray()</tt>.
@@ -384,9 +383,9 @@
}
/**
- * Test for equality, coping with nulls.
+ * Tests for equality, coping with nulls.
*/
private static boolean eq(Object o1, Object o2) {
- return (o1 == null ? o2 == null : o1.equals(o2));
+ return (o1 == null) ? o2 == null : o1.equals(o2);
}
}
--- a/jdk/src/share/classes/java/util/concurrent/CountDownLatch.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/CountDownLatch.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,8 +34,7 @@
*/
package java.util.concurrent;
-import java.util.concurrent.locks.*;
-import java.util.concurrent.atomic.*;
+import java.util.concurrent.locks.AbstractQueuedSynchronizer;
/**
* A synchronization aid that allows one or more threads to wait until
@@ -73,7 +72,7 @@
* until all workers have completed.
* </ul>
*
- * <pre>
+ * <pre> {@code
* class Driver { // ...
* void main() throws InterruptedException {
* CountDownLatch startSignal = new CountDownLatch(1);
@@ -105,9 +104,7 @@
* }
*
* void doWork() { ... }
- * }
- *
- * </pre>
+ * }}</pre>
*
* <p>Another typical usage would be to divide a problem into N parts,
* describe each part with a Runnable that executes that portion and
@@ -116,7 +113,7 @@
* will be able to pass through await. (When threads must repeatedly
* count down in this way, instead use a {@link CyclicBarrier}.)
*
- * <pre>
+ * <pre> {@code
* class Driver2 { // ...
* void main() throws InterruptedException {
* CountDownLatch doneSignal = new CountDownLatch(N);
@@ -144,9 +141,7 @@
* }
*
* void doWork() { ... }
- * }
- *
- * </pre>
+ * }}</pre>
*
* <p>Memory consistency effects: Until the count reaches
* zero, actions in a thread prior to calling
--- a/jdk/src/share/classes/java/util/concurrent/CyclicBarrier.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/CyclicBarrier.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,7 +34,8 @@
*/
package java.util.concurrent;
-import java.util.concurrent.locks.*;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
/**
* A synchronization aid that allows a set of threads to all wait for
@@ -52,7 +53,8 @@
*
* <p><b>Sample usage:</b> Here is an example of
* using a barrier in a parallel decomposition design:
- * <pre>
+ *
+ * <pre> {@code
* class Solver {
* final int N;
* final float[][] data;
@@ -90,8 +92,8 @@
*
* waitUntilDone();
* }
- * }
- * </pre>
+ * }}</pre>
+ *
* Here, each worker thread processes a row of the matrix then waits at the
* barrier until all rows have been processed. When all rows are processed
* the supplied {@link Runnable} barrier action is executed and merges the
@@ -105,9 +107,10 @@
* {@link #await} returns the arrival index of that thread at the barrier.
* You can then choose which thread should execute the barrier action, for
* example:
- * <pre> if (barrier.await() == 0) {
- * // log the completion of this iteration
- * }</pre>
+ * <pre> {@code
+ * if (barrier.await() == 0) {
+ * // log the completion of this iteration
+ * }}</pre>
*
* <p>The <tt>CyclicBarrier</tt> uses an all-or-none breakage model
* for failed synchronization attempts: If a thread leaves a barrier
@@ -204,21 +207,21 @@
throw new InterruptedException();
}
- int index = --count;
- if (index == 0) { // tripped
- boolean ranAction = false;
- try {
- final Runnable command = barrierCommand;
- if (command != null)
- command.run();
- ranAction = true;
- nextGeneration();
- return 0;
- } finally {
- if (!ranAction)
- breakBarrier();
- }
- }
+ int index = --count;
+ if (index == 0) { // tripped
+ boolean ranAction = false;
+ try {
+ final Runnable command = barrierCommand;
+ if (command != null)
+ command.run();
+ ranAction = true;
+ nextGeneration();
+ return 0;
+ } finally {
+ if (!ranAction)
+ breakBarrier();
+ }
+ }
// loop until tripped, broken, interrupted, or timed out
for (;;) {
@@ -354,7 +357,7 @@
try {
return dowait(false, 0L);
} catch (TimeoutException toe) {
- throw new Error(toe); // cannot happen;
+ throw new Error(toe); // cannot happen
}
}
--- a/jdk/src/share/classes/java/util/concurrent/Delayed.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/Delayed.java Fri Oct 26 21:34:24 2012 +0100
@@ -35,8 +35,6 @@
package java.util.concurrent;
-import java.util.*;
-
/**
* A mix-in style interface for marking objects that should be
* acted upon after a given delay.
--- a/jdk/src/share/classes/java/util/concurrent/ExecutionException.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ExecutionException.java Fri Oct 26 21:34:24 2012 +0100
@@ -79,11 +79,9 @@
/**
* Constructs an <tt>ExecutionException</tt> with the specified cause.
- * The detail message is set to:
- * <pre>
- * (cause == null ? null : cause.toString())</pre>
- * (which typically contains the class and detail message of
- * <tt>cause</tt>).
+ * The detail message is set to {@code (cause == null ? null :
+ * cause.toString())} (which typically contains the class and
+ * detail message of {@code cause}).
*
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method)
--- a/jdk/src/share/classes/java/util/concurrent/Executor.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/Executor.java Fri Oct 26 21:34:24 2012 +0100
@@ -56,23 +56,23 @@
* executor can run the submitted task immediately in the caller's
* thread:
*
- * <pre>
+ * <pre> {@code
* class DirectExecutor implements Executor {
- * public void execute(Runnable r) {
- * r.run();
- * }
- * }</pre>
+ * public void execute(Runnable r) {
+ * r.run();
+ * }
+ * }}</pre>
*
* More typically, tasks are executed in some thread other
* than the caller's thread. The executor below spawns a new thread
* for each task.
*
- * <pre>
+ * <pre> {@code
* class ThreadPerTaskExecutor implements Executor {
- * public void execute(Runnable r) {
- * new Thread(r).start();
- * }
- * }</pre>
+ * public void execute(Runnable r) {
+ * new Thread(r).start();
+ * }
+ * }}</pre>
*
* Many <tt>Executor</tt> implementations impose some sort of
* limitation on how and when tasks are scheduled. The executor below
--- a/jdk/src/share/classes/java/util/concurrent/ExecutorService.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ExecutorService.java Fri Oct 26 21:34:24 2012 +0100
@@ -36,8 +36,6 @@
package java.util.concurrent;
import java.util.List;
import java.util.Collection;
-import java.security.PrivilegedAction;
-import java.security.PrivilegedExceptionAction;
/**
* An {@link Executor} that provides methods to manage termination and
@@ -73,7 +71,7 @@
* pool service incoming requests. It uses the preconfigured {@link
* Executors#newFixedThreadPool} factory method:
*
- * <pre>
+ * <pre> {@code
* class NetworkService implements Runnable {
* private final ServerSocket serverSocket;
* private final ExecutorService pool;
@@ -101,14 +99,13 @@
* public void run() {
* // read and service request on socket
* }
- * }
- * </pre>
+ * }}</pre>
*
* The following method shuts down an <tt>ExecutorService</tt> in two phases,
* first by calling <tt>shutdown</tt> to reject incoming tasks, and then
* calling <tt>shutdownNow</tt>, if necessary, to cancel any lingering tasks:
*
- * <pre>
+ * <pre> {@code
* void shutdownAndAwaitTermination(ExecutorService pool) {
* pool.shutdown(); // Disable new tasks from being submitted
* try {
@@ -125,8 +122,7 @@
* // Preserve interrupt status
* Thread.currentThread().interrupt();
* }
- * }
- * </pre>
+ * }}</pre>
*
* <p>Memory consistency effects: Actions in a thread prior to the
* submission of a {@code Runnable} or {@code Callable} task to an
@@ -214,7 +210,6 @@
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
-
/**
* Submits a value-returning task for execution and returns a
* Future representing the pending results of the task. The
@@ -286,7 +281,6 @@
* @throws RejectedExecutionException if any task cannot be
* scheduled for execution
*/
-
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
--- a/jdk/src/share/classes/java/util/concurrent/Executors.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/Executors.java Fri Oct 26 21:34:24 2012 +0100
@@ -686,16 +686,16 @@
super(executor);
e = executor;
}
- public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+ public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
return e.schedule(command, delay, unit);
}
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
return e.schedule(callable, delay, unit);
}
- public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
+ public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
return e.scheduleAtFixedRate(command, initialDelay, period, unit);
}
- public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
+ public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
return e.scheduleWithFixedDelay(command, initialDelay, delay, unit);
}
}
--- a/jdk/src/share/classes/java/util/concurrent/Future.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/Future.java Fri Oct 26 21:34:24 2012 +0100
@@ -76,12 +76,12 @@
* implements <tt>Runnable</tt>, and so may be executed by an <tt>Executor</tt>.
* For example, the above construction with <tt>submit</tt> could be replaced by:
* <pre> {@code
- * FutureTask<String> future =
- * new FutureTask<String>(new Callable<String>() {
- * public String call() {
- * return searcher.search(target);
- * }});
- * executor.execute(future);}</pre>
+ * FutureTask<String> future =
+ * new FutureTask<String>(new Callable<String>() {
+ * public String call() {
+ * return searcher.search(target);
+ * }});
+ * executor.execute(future);}</pre>
*
* <p>Memory consistency effects: Actions taken by the asynchronous computation
* <a href="package-summary.html#MemoryVisibility"> <i>happen-before</i></a>
--- a/jdk/src/share/classes/java/util/concurrent/LinkedBlockingDeque.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/LinkedBlockingDeque.java Fri Oct 26 21:34:24 2012 +0100
@@ -73,7 +73,7 @@
*/
public class LinkedBlockingDeque<E>
extends AbstractQueue<E>
- implements BlockingDeque<E>, java.io.Serializable {
+ implements BlockingDeque<E>, java.io.Serializable {
/*
* Implemented as a simple doubly-linked list protected by a
@@ -922,8 +922,7 @@
* The following code can be used to dump the deque into a newly
* allocated array of {@code String}:
*
- * <pre>
- * String[] y = x.toArray(new String[0]);</pre>
+ * <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
*
* Note that {@code toArray(new Object[0])} is identical in function to
* {@code toArray()}.
@@ -1045,7 +1044,7 @@
/**
* The next node to return in next()
*/
- Node<E> next;
+ Node<E> next;
/**
* nextItem holds on to item fields because once we claim that
@@ -1153,11 +1152,10 @@
}
/**
- * Save the state of this deque to a stream (that is, serialize it).
+ * Saves this deque to a stream (that is, serializes it).
*
* @serialData The capacity (int), followed by elements (each an
* {@code Object}) in the proper order, followed by a null
- * @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
@@ -1177,9 +1175,7 @@
}
/**
- * Reconstitute this deque from a stream (that is,
- * deserialize it).
- * @param s the stream
+ * Reconstitutes this deque from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
--- a/jdk/src/share/classes/java/util/concurrent/LinkedBlockingQueue.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/LinkedBlockingQueue.java Fri Oct 26 21:34:24 2012 +0100
@@ -73,7 +73,6 @@
* @since 1.5
* @author Doug Lea
* @param <E> the type of elements held in this collection
- *
*/
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
@@ -135,13 +134,13 @@
private final int capacity;
/** Current number of elements */
- private final AtomicInteger count = new AtomicInteger(0);
+ private final AtomicInteger count = new AtomicInteger();
/**
* Head of linked list.
* Invariant: head.item == null
*/
- private transient Node<E> head;
+ transient Node<E> head;
/**
* Tail of linked list.
@@ -291,7 +290,6 @@
}
}
-
// this doc comment is overridden to remove the reference to collections
// greater in size than Integer.MAX_VALUE
/**
@@ -430,7 +428,6 @@
return c >= 0;
}
-
public E take() throws InterruptedException {
E x;
int c = -1;
@@ -630,8 +627,7 @@
* The following code can be used to dump the queue into a newly
* allocated array of {@code String}:
*
- * <pre>
- * String[] y = x.toArray(new String[0]);</pre>
+ * <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
*
* Note that {@code toArray(new Object[0])} is identical in function to
* {@code toArray()}.
@@ -777,7 +773,7 @@
* @return an iterator over the elements in this queue in proper sequence
*/
public Iterator<E> iterator() {
- return new Itr();
+ return new Itr();
}
private class Itr implements Iterator<E> {
@@ -860,12 +856,11 @@
}
/**
- * Save the state to a stream (that is, serialize it).
+ * Saves this queue to a stream (that is, serializes it).
*
* @serialData The capacity is emitted (int), followed by all of
* its elements (each an {@code Object}) in the proper order,
* followed by a null
- * @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
@@ -887,10 +882,7 @@
}
/**
- * Reconstitute this queue instance from a stream (that is,
- * deserialize it).
- *
- * @param s the stream
+ * Reconstitutes this queue from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
--- a/jdk/src/share/classes/java/util/concurrent/LinkedTransferQueue.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/LinkedTransferQueue.java Fri Oct 26 21:34:24 2012 +0100
@@ -695,7 +695,7 @@
* @return matched item, or e if unmatched on interrupt or timeout
*/
private E awaitMatch(Node s, Node pred, E e, boolean timed, long nanos) {
- long lastTime = timed ? System.nanoTime() : 0L;
+ final long deadline = timed ? System.nanoTime() + nanos : 0L;
Thread w = Thread.currentThread();
int spins = -1; // initialized after first item and cancel checks
ThreadLocalRandom randomYields = null; // bound if needed
@@ -726,10 +726,9 @@
s.waiter = w; // request unpark then recheck
}
else if (timed) {
- long now = System.nanoTime();
- if ((nanos -= now - lastTime) > 0)
+ nanos = deadline - System.nanoTime();
+ if (nanos > 0L)
LockSupport.parkNanos(this, nanos);
- lastTime = now;
}
else {
LockSupport.park(this);
@@ -1294,11 +1293,10 @@
}
/**
- * Saves the state to a stream (that is, serializes it).
+ * Saves this queue to a stream (that is, serializes it).
*
* @serialData All of the elements (each an {@code E}) in
* the proper order, followed by a null
- * @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
@@ -1310,10 +1308,7 @@
}
/**
- * Reconstitutes the Queue instance from a stream (that is,
- * deserializes it).
- *
- * @param s the stream
+ * Reconstitutes this queue from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
--- a/jdk/src/share/classes/java/util/concurrent/RecursiveAction.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/RecursiveAction.java Fri Oct 26 21:34:24 2012 +0100
@@ -39,37 +39,49 @@
* A recursive resultless {@link ForkJoinTask}. This class
* establishes conventions to parameterize resultless actions as
* {@code Void} {@code ForkJoinTask}s. Because {@code null} is the
- * only valid value of type {@code Void}, methods such as join always
- * return {@code null} upon completion.
+ * only valid value of type {@code Void}, methods such as {@code join}
+ * always return {@code null} upon completion.
*
- * <p><b>Sample Usages.</b> Here is a sketch of a ForkJoin sort that
- * sorts a given {@code long[]} array:
+ * <p><b>Sample Usages.</b> Here is a simple but complete ForkJoin
+ * sort that sorts a given {@code long[]} array:
*
* <pre> {@code
- * class SortTask extends RecursiveAction {
- * final long[] array; final int lo; final int hi;
+ * static class SortTask extends RecursiveAction {
+ * final long[] array; final int lo, hi;
* SortTask(long[] array, int lo, int hi) {
* this.array = array; this.lo = lo; this.hi = hi;
* }
+ * SortTask(long[] array) { this(array, 0, array.length); }
* protected void compute() {
* if (hi - lo < THRESHOLD)
- * sequentiallySort(array, lo, hi);
+ * sortSequentially(lo, hi);
* else {
* int mid = (lo + hi) >>> 1;
* invokeAll(new SortTask(array, lo, mid),
* new SortTask(array, mid, hi));
- * merge(array, lo, hi);
+ * merge(lo, mid, hi);
* }
* }
+ * // implementation details follow:
+ * final static int THRESHOLD = 1000;
+ * void sortSequentially(int lo, int hi) {
+ * Arrays.sort(array, lo, hi);
+ * }
+ * void merge(int lo, int mid, int hi) {
+ * long[] buf = Arrays.copyOfRange(array, lo, mid);
+ * for (int i = 0, j = lo, k = mid; i < buf.length; j++)
+ * array[j] = (k == hi || buf[i] < array[k]) ?
+ * buf[i++] : array[k++];
+ * }
* }}</pre>
*
* You could then sort {@code anArray} by creating {@code new
- * SortTask(anArray, 0, anArray.length-1) } and invoking it in a
- * ForkJoinPool. As a more concrete simple example, the following
- * task increments each element of an array:
+ * SortTask(anArray)} and invoking it in a ForkJoinPool. As a more
+ * concrete simple example, the following task increments each element
+ * of an array:
* <pre> {@code
* class IncrementTask extends RecursiveAction {
- * final long[] array; final int lo; final int hi;
+ * final long[] array; final int lo, hi;
* IncrementTask(long[] array, int lo, int hi) {
* this.array = array; this.lo = lo; this.hi = hi;
* }
--- a/jdk/src/share/classes/java/util/concurrent/RejectedExecutionException.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/RejectedExecutionException.java Fri Oct 26 21:34:24 2012 +0100
@@ -78,8 +78,8 @@
/**
* Constructs a <tt>RejectedExecutionException</tt> with the
- * specified cause. The detail message is set to: <pre> (cause ==
- * null ? null : cause.toString())</pre> (which typically contains
+ * specified cause. The detail message is set to {@code (cause ==
+ * null ? null : cause.toString())} (which typically contains
* the class and detail message of <tt>cause</tt>).
*
* @param cause the cause (which is saved for later retrieval by the
--- a/jdk/src/share/classes/java/util/concurrent/ScheduledExecutorService.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ScheduledExecutorService.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,8 +34,6 @@
*/
package java.util.concurrent;
-import java.util.concurrent.atomic.*;
-import java.util.*;
/**
* An {@link ExecutorService} that can schedule commands to run after a given
--- a/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java Fri Oct 26 21:34:24 2012 +0100
@@ -223,7 +223,7 @@
}
/**
- * Creates a one-shot action with given nanoTime-based trigger.
+ * Creates a one-shot action with given nanoTime-based trigger time.
*/
ScheduledFutureTask(Callable<V> callable, long ns) {
super(callable);
@@ -237,7 +237,7 @@
}
public int compareTo(Delayed other) {
- if (other == this) // compare zero ONLY if same object
+ if (other == this) // compare zero if same object
return 0;
if (other instanceof ScheduledFutureTask) {
ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
@@ -251,9 +251,8 @@
else
return 1;
}
- long d = (getDelay(NANOSECONDS) -
- other.getDelay(NANOSECONDS));
- return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
+ long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
+ return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
}
/**
@@ -862,7 +861,7 @@
private final Condition available = lock.newCondition();
/**
- * Set f's heapIndex if it is a ScheduledFutureTask.
+ * Sets f's heapIndex if it is a ScheduledFutureTask.
*/
private void setIndex(RunnableScheduledFuture<?> f, int idx) {
if (f instanceof ScheduledFutureTask)
@@ -870,7 +869,7 @@
}
/**
- * Sift element added at bottom up to its heap-ordered spot.
+ * Sifts element added at bottom up to its heap-ordered spot.
* Call only when holding lock.
*/
private void siftUp(int k, RunnableScheduledFuture<?> key) {
@@ -888,7 +887,7 @@
}
/**
- * Sift element added at top down to its heap-ordered spot.
+ * Sifts element added at top down to its heap-ordered spot.
* Call only when holding lock.
*/
private void siftDown(int k, RunnableScheduledFuture<?> key) {
@@ -910,7 +909,7 @@
}
/**
- * Resize the heap array. Call only when holding lock.
+ * Resizes the heap array. Call only when holding lock.
*/
private void grow() {
int oldCapacity = queue.length;
@@ -921,7 +920,7 @@
}
/**
- * Find index of given object, or -1 if absent
+ * Finds index of given object, or -1 if absent.
*/
private int indexOf(Object x) {
if (x != null) {
@@ -1162,15 +1161,14 @@
}
/**
- * Return and remove first element only if it is expired.
+ * Returns first element only if it is expired.
* Used only by drainTo. Call only when holding lock.
*/
- private RunnableScheduledFuture<?> pollExpired() {
+ private RunnableScheduledFuture<?> peekExpired() {
// assert lock.isHeldByCurrentThread();
RunnableScheduledFuture<?> first = queue[0];
- if (first == null || first.getDelay(NANOSECONDS) > 0)
- return null;
- return finishPoll(first);
+ return (first == null || first.getDelay(NANOSECONDS) > 0) ?
+ null : first;
}
public int drainTo(Collection<? super Runnable> c) {
@@ -1183,8 +1181,9 @@
try {
RunnableScheduledFuture<?> first;
int n = 0;
- while ((first = pollExpired()) != null) {
- c.add(first);
+ while ((first = peekExpired()) != null) {
+ c.add(first); // In this order, in case add() throws.
+ finishPoll(first);
++n;
}
return n;
@@ -1205,8 +1204,9 @@
try {
RunnableScheduledFuture<?> first;
int n = 0;
- while (n < maxElements && (first = pollExpired()) != null) {
- c.add(first);
+ while (n < maxElements && (first = peekExpired()) != null) {
+ c.add(first); // In this order, in case add() throws.
+ finishPoll(first);
++n;
}
return n;
--- a/jdk/src/share/classes/java/util/concurrent/Semaphore.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/Semaphore.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,9 +34,8 @@
*/
package java.util.concurrent;
-import java.util.*;
-import java.util.concurrent.locks.*;
-import java.util.concurrent.atomic.*;
+import java.util.Collection;
+import java.util.concurrent.locks.AbstractQueuedSynchronizer;
/**
* A counting semaphore. Conceptually, a semaphore maintains a set of
@@ -49,7 +48,7 @@
* <p>Semaphores are often used to restrict the number of threads than can
* access some (physical or logical) resource. For example, here is
* a class that uses a semaphore to control access to a pool of items:
- * <pre>
+ * <pre> {@code
* class Pool {
* private static final int MAX_AVAILABLE = 100;
* private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
@@ -91,9 +90,7 @@
* }
* return false;
* }
- *
- * }
- * </pre>
+ * }}</pre>
*
* <p>Before obtaining an item each thread must acquire a permit from
* the semaphore, guaranteeing that an item is available for use. When
@@ -111,7 +108,7 @@
* exclusion lock. This is more commonly known as a <em>binary
* semaphore</em>, because it only has two states: one permit
* available, or zero permits available. When used in this way, the
- * binary semaphore has the property (unlike many {@link Lock}
+ * binary semaphore has the property (unlike many {@link java.util.concurrent.locks.Lock}
* implementations), that the "lock" can be released by a
* thread other than the owner (as semaphores have no notion of
* ownership). This can be useful in some specialized contexts, such
@@ -155,9 +152,7 @@
*
* @since 1.5
* @author Doug Lea
- *
*/
-
public class Semaphore implements java.io.Serializable {
private static final long serialVersionUID = -3222578661600680210L;
/** All mechanics via AbstractQueuedSynchronizer subclass */
@@ -493,7 +488,6 @@
*
* @param permits the number of permits to acquire
* @throws IllegalArgumentException if {@code permits} is negative
- *
*/
public void acquireUninterruptibly(int permits) {
if (permits < 0) throw new IllegalArgumentException();
--- a/jdk/src/share/classes/java/util/concurrent/SynchronousQueue.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/SynchronousQueue.java Fri Oct 26 21:34:24 2012 +0100
@@ -35,7 +35,8 @@
*/
package java.util.concurrent;
-import java.util.concurrent.locks.*;
+import java.util.concurrent.locks.LockSupport;
+import java.util.concurrent.locks.ReentrantLock;
import java.util.*;
/**
@@ -222,7 +223,7 @@
/** Node is fulfilling another unfulfilled DATA or REQUEST */
static final int FULFILLING = 2;
- /** Return true if m has fulfilling bit set */
+ /** Returns true if m has fulfilling bit set. */
static boolean isFulfilling(int m) { return (m & FULFILLING) != 0; }
/** Node class for TransferStacks. */
@@ -430,9 +431,8 @@
* and don't wait at all, so are trapped in transfer
* method rather than calling awaitFulfill.
*/
- long lastTime = timed ? System.nanoTime() : 0;
+ final long deadline = timed ? System.nanoTime() + nanos : 0L;
Thread w = Thread.currentThread();
- SNode h = head;
int spins = (shouldSpin(s) ?
(timed ? maxTimedSpins : maxUntimedSpins) : 0);
for (;;) {
@@ -442,10 +442,8 @@
if (m != null)
return m;
if (timed) {
- long now = System.nanoTime();
- nanos -= now - lastTime;
- lastTime = now;
- if (nanos <= 0) {
+ nanos = deadline - System.nanoTime();
+ if (nanos <= 0L) {
s.tryCancel();
continue;
}
@@ -737,7 +735,7 @@
*/
Object awaitFulfill(QNode s, E e, boolean timed, long nanos) {
/* Same idea as TransferStack.awaitFulfill */
- long lastTime = timed ? System.nanoTime() : 0;
+ final long deadline = timed ? System.nanoTime() + nanos : 0L;
Thread w = Thread.currentThread();
int spins = ((head.next == s) ?
(timed ? maxTimedSpins : maxUntimedSpins) : 0);
@@ -748,10 +746,8 @@
if (x != e)
return x;
if (timed) {
- long now = System.nanoTime();
- nanos -= now - lastTime;
- lastTime = now;
- if (nanos <= 0) {
+ nanos = deadline - System.nanoTime();
+ if (nanos <= 0L) {
s.tryCancel(e);
continue;
}
@@ -874,9 +870,9 @@
* @throws InterruptedException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
- public void put(E o) throws InterruptedException {
- if (o == null) throw new NullPointerException();
- if (transferer.transfer(o, false, 0) == null) {
+ public void put(E e) throws InterruptedException {
+ if (e == null) throw new NullPointerException();
+ if (transferer.transfer(e, false, 0) == null) {
Thread.interrupted();
throw new InterruptedException();
}
@@ -891,10 +887,10 @@
* @throws InterruptedException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
- public boolean offer(E o, long timeout, TimeUnit unit)
+ public boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException {
- if (o == null) throw new NullPointerException();
- if (transferer.transfer(o, true, unit.toNanos(timeout)) != null)
+ if (e == null) throw new NullPointerException();
+ if (transferer.transfer(e, true, unit.toNanos(timeout)) != null)
return true;
if (!Thread.interrupted())
return false;
@@ -1162,9 +1158,7 @@
private WaitQueue waitingConsumers;
/**
- * Saves the state to a stream (that is, serializes it).
- *
- * @param s the stream
+ * Saves this queue to a stream (that is, serializes it).
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
@@ -1182,6 +1176,9 @@
s.defaultWriteObject();
}
+ /**
+ * Reconstitutes this queue from a stream (that is, deserializes it).
+ */
private void readObject(final java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
--- a/jdk/src/share/classes/java/util/concurrent/ThreadFactory.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/ThreadFactory.java Fri Oct 26 21:34:24 2012 +0100
@@ -42,13 +42,12 @@
*
* <p>
* The simplest implementation of this interface is just:
- * <pre>
+ * <pre> {@code
* class SimpleThreadFactory implements ThreadFactory {
* public Thread newThread(Runnable r) {
* return new Thread(r);
* }
- * }
- * </pre>
+ * }}</pre>
*
* The {@link Executors#defaultThreadFactory} method provides a more
* useful simple implementation, that sets the created thread context
--- a/jdk/src/share/classes/java/util/concurrent/TimeUnit.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/TimeUnit.java Fri Oct 26 21:34:24 2012 +0100
@@ -52,14 +52,14 @@
* the following code will timeout in 50 milliseconds if the {@link
* java.util.concurrent.locks.Lock lock} is not available:
*
- * <pre> Lock lock = ...;
- * if (lock.tryLock(50L, TimeUnit.MILLISECONDS)) ...
- * </pre>
+ * <pre> {@code
+ * Lock lock = ...;
+ * if (lock.tryLock(50L, TimeUnit.MILLISECONDS)) ...}</pre>
+ *
* while this code will timeout in 50 seconds:
- * <pre>
- * Lock lock = ...;
- * if (lock.tryLock(50L, TimeUnit.SECONDS)) ...
- * </pre>
+ * <pre> {@code
+ * Lock lock = ...;
+ * if (lock.tryLock(50L, TimeUnit.SECONDS)) ...}</pre>
*
* Note however, that there is no guarantee that a particular timeout
* implementation will be able to notice the passage of time at the
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java Fri Oct 26 21:34:24 2012 +0100
@@ -245,7 +245,6 @@
return Integer.toString(get());
}
-
/**
* Returns the value of this {@code AtomicInteger} as an {@code int}.
*/
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java Fri Oct 26 21:34:24 2012 +0100
@@ -59,7 +59,7 @@
* @author Doug Lea
* @param <T> The type of the object holding the updatable field
*/
-public abstract class AtomicIntegerFieldUpdater<T> {
+public abstract class AtomicIntegerFieldUpdater<T> {
/**
* Creates and returns an updater for objects with the given field.
* The Class argument is needed to check that reflective types and
@@ -274,9 +274,9 @@
private final Class<?> cclass;
AtomicIntegerFieldUpdaterImpl(final Class<T> tclass, final String fieldName) {
- Field field = null;
- Class<?> caller = null;
- int modifiers = 0;
+ final Field field;
+ final Class<?> caller;
+ final int modifiers;
try {
field = AccessController.doPrivileged(
new PrivilegedExceptionAction<Field>() {
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLong.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLong.java Fri Oct 26 21:34:24 2012 +0100
@@ -259,7 +259,6 @@
return Long.toString(get());
}
-
/**
* Returns the value of this {@code AtomicLong} as an {@code int}
* after a narrowing primitive conversion.
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java Fri Oct 26 21:34:24 2012 +0100
@@ -59,7 +59,7 @@
* @author Doug Lea
* @param <T> The type of the object holding the updatable field
*/
-public abstract class AtomicLongFieldUpdater<T> {
+public abstract class AtomicLongFieldUpdater<T> {
/**
* Creates and returns an updater for objects with the given field.
* The Class argument is needed to check that reflective types and
@@ -274,9 +274,9 @@
private final Class<?> cclass;
CASUpdater(final Class<T> tclass, final String fieldName) {
- Field field = null;
- Class<?> caller = null;
- int modifiers = 0;
+ final Field field;
+ final Class<?> caller;
+ final int modifiers;
try {
field = AccessController.doPrivileged(
new PrivilegedExceptionAction<Field>() {
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReference.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReference.java Fri Oct 26 21:34:24 2012 +0100
@@ -44,7 +44,7 @@
* @author Doug Lea
* @param <V> The type of object referred to by this reference
*/
-public class AtomicReference<V> implements java.io.Serializable {
+public class AtomicReference<V> implements java.io.Serializable {
private static final long serialVersionUID = -1848883965231344442L;
private static final Unsafe unsafe = Unsafe.getUnsafe();
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java Fri Oct 26 21:34:24 2012 +0100
@@ -35,8 +35,8 @@
package java.util.concurrent.atomic;
+import java.util.Arrays;
import java.lang.reflect.Array;
-import java.util.Arrays;
import sun.misc.Unsafe;
/**
@@ -151,7 +151,6 @@
unsafe.putOrderedObject(array, checkedByteOffset(i), newValue);
}
-
/**
* Atomically sets the element at position {@code i} to the given
* value and returns the old value.
@@ -225,10 +224,10 @@
/**
* Reconstitutes the instance from a stream (that is, deserializes it).
- * @param s the stream
*/
private void readObject(java.io.ObjectInputStream s)
- throws java.io.IOException, ClassNotFoundException {
+ throws java.io.IOException, ClassNotFoundException,
+ java.io.InvalidObjectException {
// Note: This must be changed if any additional fields are defined
Object a = s.readFields().get("array", null);
if (a == null || !a.getClass().isArray())
--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java Fri Oct 26 21:34:24 2012 +0100
@@ -206,10 +206,10 @@
AtomicReferenceFieldUpdaterImpl(final Class<T> tclass,
Class<V> vclass,
final String fieldName) {
- Field field = null;
- Class<?> fieldClass = null;
- Class<?> caller = null;
- int modifiers = 0;
+ final Field field;
+ final Class<?> fieldClass;
+ final Class<?> caller;
+ final int modifiers;
try {
field = AccessController.doPrivileged(
new PrivilegedExceptionAction<Field>() {
@@ -220,12 +220,12 @@
caller = sun.reflect.Reflection.getCallerClass(3);
modifiers = field.getModifiers();
sun.reflect.misc.ReflectUtil.ensureMemberAccess(
- caller, tclass, null, modifiers);
+ caller, tclass, null, modifiers);
ClassLoader cl = tclass.getClassLoader();
ClassLoader ccl = caller.getClassLoader();
if ((ccl != null) && (ccl != cl) &&
((cl == null) || !isAncestor(cl, ccl))) {
- sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
+ sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
}
fieldClass = field.getType();
} catch (PrivilegedActionException pae) {
@@ -315,7 +315,7 @@
}
@SuppressWarnings("unchecked")
- public V get(T obj) {
+ public V get(T obj) {
if (obj == null || obj.getClass() != tclass || cclass != null)
targetCheck(obj);
return (V)unsafe.getObjectVolatile(obj, offset);
@@ -326,14 +326,14 @@
return;
}
throw new RuntimeException(
- new IllegalAccessException("Class " +
- cclass.getName() +
- " can not access a protected member of class " +
- tclass.getName() +
- " using an instance of " +
- obj.getClass().getName()
- )
- );
+ new IllegalAccessException("Class " +
+ cclass.getName() +
+ " can not access a protected member of class " +
+ tclass.getName() +
+ " using an instance of " +
+ obj.getClass().getName()
+ )
+ );
}
}
}
--- a/jdk/src/share/classes/java/util/concurrent/atomic/package-info.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/package-info.java Fri Oct 26 21:34:24 2012 +0100
@@ -40,9 +40,7 @@
* array elements to those that also provide an atomic conditional update
* operation of the form:
*
- * <pre>
- * boolean compareAndSet(expectedValue, updateValue);
- * </pre>
+ * <pre> {@code boolean compareAndSet(expectedValue, updateValue);}</pre>
*
* <p>This method (which varies in argument types across different
* classes) atomically sets a variable to the {@code updateValue} if it
@@ -69,19 +67,36 @@
* {@code AtomicInteger} provide atomic increment methods. One
* application is to generate sequence numbers, as in:
*
- * <pre>
+ * <pre> {@code
* class Sequencer {
* private final AtomicLong sequenceNumber
* = new AtomicLong(0);
* public long next() {
* return sequenceNumber.getAndIncrement();
* }
- * }
- * </pre>
+ * }}</pre>
+ *
+ * <p>It is straightforward to define new utility functions that, like
+ * {@code getAndIncrement}, apply a function to a value atomically.
+ * For example, given some transformation
+ * <pre> {@code long transform(long input)}</pre>
+ *
+ * write your utility method as follows:
+ * <pre> {@code
+ * long getAndTransform(AtomicLong var) {
+ * while (true) {
+ * long current = var.get();
+ * long next = transform(current);
+ * if (var.compareAndSet(current, next))
+ * return current;
+ * // return next; for transformAndGet
+ * }
+ * }}</pre>
*
* <p>The memory effects for accesses and updates of atomics generally
- * follow the rules for volatiles, as stated in section 17.4 of
- * <cite>The Java™ Language Specification</cite>.
+ * follow the rules for volatiles, as stated in
+ * <a href="http://docs.oracle.com/javase/specs/jls/se7/html/index.html">
+ * The Java Language Specification, Third Edition (17.4 Memory Model)</a>:
*
* <ul>
*
@@ -189,9 +204,9 @@
* {@code byte} values, and cast appropriately.
*
* You can also hold floats using
- * {@link java.lang.Float#floatToIntBits} and
+ * {@link java.lang.Float#floatToRawIntBits} and
* {@link java.lang.Float#intBitsToFloat} conversions, and doubles using
- * {@link java.lang.Double#doubleToLongBits} and
+ * {@link java.lang.Double#doubleToRawLongBits} and
* {@link java.lang.Double#longBitsToDouble} conversions.
*
* @since 1.5
--- a/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,9 +34,10 @@
*/
package java.util.concurrent.locks;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
+import java.util.concurrent.TimeUnit;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
import sun.misc.Unsafe;
/**
@@ -598,7 +599,7 @@
/**
* Convenience method to interrupt current thread.
*/
- private static void selfInterrupt() {
+ static void selfInterrupt() {
Thread.currentThread().interrupt();
}
@@ -686,8 +687,10 @@
* @return {@code true} if acquired
*/
private boolean doAcquireNanos(long arg, long nanosTimeout)
- throws InterruptedException {
- long lastTime = System.nanoTime();
+ throws InterruptedException {
+ if (nanosTimeout <= 0L)
+ return false;
+ final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
@@ -699,14 +702,12 @@
failed = false;
return true;
}
- if (nanosTimeout <= 0)
+ nanosTimeout = deadline - System.nanoTime();
+ if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
- long now = System.nanoTime();
- nanosTimeout -= now - lastTime;
- lastTime = now;
if (Thread.interrupted())
throw new InterruptedException();
}
@@ -786,9 +787,10 @@
* @return {@code true} if acquired
*/
private boolean doAcquireSharedNanos(long arg, long nanosTimeout)
- throws InterruptedException {
-
- long lastTime = System.nanoTime();
+ throws InterruptedException {
+ if (nanosTimeout <= 0L)
+ return false;
+ final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
@@ -803,14 +805,12 @@
return true;
}
}
- if (nanosTimeout <= 0)
+ nanosTimeout = deadline - System.nanoTime();
+ if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
- long now = System.nanoTime();
- nanosTimeout -= now - lastTime;
- lastTime = now;
if (Thread.interrupted())
throw new InterruptedException();
}
@@ -1260,7 +1260,7 @@
* due to the queue being empty.
*
* <p>This method is designed to be used by a fair synchronizer to
- * avoid <a href="AbstractQueuedSynchronizer#barging">barging</a>.
+ * avoid <a href="AbstractQueuedSynchronizer.html#barging">barging</a>.
* Such a synchronizer's {@link #tryAcquire} method should return
* {@code false}, and its {@link #tryAcquireShared} method should
* return a negative value, if this method returns {@code true}
@@ -1520,8 +1520,6 @@
* @throws NullPointerException if the condition is null
*/
public final boolean owns(ConditionObject condition) {
- if (condition == null)
- throw new NullPointerException();
return condition.isOwnedBy(this);
}
@@ -1742,9 +1740,8 @@
* Implements uninterruptible condition wait.
* <ol>
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -1803,9 +1800,8 @@
* <ol>
* <li> If current thread is interrupted, throw InterruptedException.
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled or interrupted.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -1836,9 +1832,8 @@
* <ol>
* <li> If current thread is interrupted, throw InterruptedException.
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled, interrupted, or timed out.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -1851,20 +1846,18 @@
throw new InterruptedException();
Node node = addConditionWaiter();
long savedState = fullyRelease(node);
- long lastTime = System.nanoTime();
+ final long deadline = System.nanoTime() + nanosTimeout;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (nanosTimeout <= 0L) {
transferAfterCancelledWait(node);
break;
}
- LockSupport.parkNanos(this, nanosTimeout);
+ if (nanosTimeout >= spinForTimeoutThreshold)
+ LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
-
- long now = System.nanoTime();
- nanosTimeout -= now - lastTime;
- lastTime = now;
+ nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
@@ -1872,7 +1865,7 @@
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
- return nanosTimeout - (System.nanoTime() - lastTime);
+ return deadline - System.nanoTime();
}
/**
@@ -1880,9 +1873,8 @@
* <ol>
* <li> If current thread is interrupted, throw InterruptedException.
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled, interrupted, or timed out.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -1892,8 +1884,6 @@
*/
public final boolean awaitUntil(Date deadline)
throws InterruptedException {
- if (deadline == null)
- throw new NullPointerException();
long abstime = deadline.getTime();
if (Thread.interrupted())
throw new InterruptedException();
@@ -1924,9 +1914,8 @@
* <ol>
* <li> If current thread is interrupted, throw InterruptedException.
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled, interrupted, or timed out.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -1936,14 +1925,12 @@
*/
public final boolean await(long time, TimeUnit unit)
throws InterruptedException {
- if (unit == null)
- throw new NullPointerException();
long nanosTimeout = unit.toNanos(time);
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
long savedState = fullyRelease(node);
- long lastTime = System.nanoTime();
+ final long deadline = System.nanoTime() + nanosTimeout;
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
@@ -1955,9 +1942,7 @@
LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
- long now = System.nanoTime();
- nanosTimeout -= now - lastTime;
- lastTime = now;
+ nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
--- a/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedSynchronizer.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/locks/AbstractQueuedSynchronizer.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,9 +34,10 @@
*/
package java.util.concurrent.locks;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
+import java.util.concurrent.TimeUnit;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
import sun.misc.Unsafe;
/**
@@ -194,7 +195,7 @@
* It also supports conditions and exposes
* one of the instrumentation methods:
*
- * <pre>
+ * <pre> {@code
* class Mutex implements Lock, java.io.Serializable {
*
* // Our internal helper class
@@ -250,15 +251,15 @@
* throws InterruptedException {
* return sync.tryAcquireNanos(1, unit.toNanos(timeout));
* }
- * }
- * </pre>
+ * }}</pre>
*
- * <p>Here is a latch class that is like a {@link CountDownLatch}
+ * <p>Here is a latch class that is like a
+ * {@link java.util.concurrent.CountDownLatch CountDownLatch}
* except that it only requires a single <tt>signal</tt> to
* fire. Because a latch is non-exclusive, it uses the <tt>shared</tt>
* acquire and release methods.
*
- * <pre>
+ * <pre> {@code
* class BooleanLatch {
*
* private static class Sync extends AbstractQueuedSynchronizer {
@@ -280,8 +281,7 @@
* public void await() throws InterruptedException {
* sync.acquireSharedInterruptibly(1);
* }
- * }
- * </pre>
+ * }}</pre>
*
* @since 1.5
* @author Doug Lea
@@ -821,7 +821,7 @@
/**
* Convenience method to interrupt current thread.
*/
- private static void selfInterrupt() {
+ static void selfInterrupt() {
Thread.currentThread().interrupt();
}
@@ -909,8 +909,10 @@
* @return {@code true} if acquired
*/
private boolean doAcquireNanos(int arg, long nanosTimeout)
- throws InterruptedException {
- long lastTime = System.nanoTime();
+ throws InterruptedException {
+ if (nanosTimeout <= 0L)
+ return false;
+ final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
@@ -922,14 +924,12 @@
failed = false;
return true;
}
- if (nanosTimeout <= 0)
+ nanosTimeout = deadline - System.nanoTime();
+ if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
- long now = System.nanoTime();
- nanosTimeout -= now - lastTime;
- lastTime = now;
if (Thread.interrupted())
throw new InterruptedException();
}
@@ -1009,9 +1009,10 @@
* @return {@code true} if acquired
*/
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
- throws InterruptedException {
-
- long lastTime = System.nanoTime();
+ throws InterruptedException {
+ if (nanosTimeout <= 0L)
+ return false;
+ final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
@@ -1026,14 +1027,12 @@
return true;
}
}
- if (nanosTimeout <= 0)
+ nanosTimeout = deadline - System.nanoTime();
+ if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
- long now = System.nanoTime();
- nanosTimeout -= now - lastTime;
- lastTime = now;
if (Thread.interrupted())
throw new InterruptedException();
}
@@ -1743,8 +1742,6 @@
* @throws NullPointerException if the condition is null
*/
public final boolean owns(ConditionObject condition) {
- if (condition == null)
- throw new NullPointerException();
return condition.isOwnedBy(this);
}
@@ -1963,9 +1960,8 @@
* Implements uninterruptible condition wait.
* <ol>
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -2024,9 +2020,8 @@
* <ol>
* <li> If current thread is interrupted, throw InterruptedException.
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled or interrupted.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -2057,9 +2052,8 @@
* <ol>
* <li> If current thread is interrupted, throw InterruptedException.
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled, interrupted, or timed out.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -2072,20 +2066,18 @@
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
- long lastTime = System.nanoTime();
+ final long deadline = System.nanoTime() + nanosTimeout;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (nanosTimeout <= 0L) {
transferAfterCancelledWait(node);
break;
}
- LockSupport.parkNanos(this, nanosTimeout);
+ if (nanosTimeout >= spinForTimeoutThreshold)
+ LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
-
- long now = System.nanoTime();
- nanosTimeout -= now - lastTime;
- lastTime = now;
+ nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
@@ -2093,7 +2085,7 @@
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
- return nanosTimeout - (System.nanoTime() - lastTime);
+ return deadline - System.nanoTime();
}
/**
@@ -2101,9 +2093,8 @@
* <ol>
* <li> If current thread is interrupted, throw InterruptedException.
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled, interrupted, or timed out.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -2113,8 +2104,6 @@
*/
public final boolean awaitUntil(Date deadline)
throws InterruptedException {
- if (deadline == null)
- throw new NullPointerException();
long abstime = deadline.getTime();
if (Thread.interrupted())
throw new InterruptedException();
@@ -2145,9 +2134,8 @@
* <ol>
* <li> If current thread is interrupted, throw InterruptedException.
* <li> Save lock state returned by {@link #getState}.
- * <li> Invoke {@link #release} with
- * saved state as argument, throwing
- * IllegalMonitorStateException if it fails.
+ * <li> Invoke {@link #release} with saved state as argument,
+ * throwing IllegalMonitorStateException if it fails.
* <li> Block until signalled, interrupted, or timed out.
* <li> Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
@@ -2157,14 +2145,12 @@
*/
public final boolean await(long time, TimeUnit unit)
throws InterruptedException {
- if (unit == null)
- throw new NullPointerException();
long nanosTimeout = unit.toNanos(time);
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
- long lastTime = System.nanoTime();
+ final long deadline = System.nanoTime() + nanosTimeout;
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
@@ -2176,9 +2162,7 @@
LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
- long now = System.nanoTime();
- nanosTimeout -= now - lastTime;
- lastTime = now;
+ nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
--- a/jdk/src/share/classes/java/util/concurrent/locks/Condition.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/locks/Condition.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,7 +34,7 @@
*/
package java.util.concurrent.locks;
-import java.util.concurrent.*;
+import java.util.concurrent.TimeUnit;
import java.util.Date;
/**
@@ -360,10 +360,9 @@
/**
* Causes the current thread to wait until it is signalled or interrupted,
* or the specified waiting time elapses. This method is behaviorally
- * equivalent to:<br>
- * <pre>
- * awaitNanos(unit.toNanos(time)) > 0
- * </pre>
+ * equivalent to:
+ * <pre> {@code awaitNanos(unit.toNanos(time)) > 0}</pre>
+ *
* @param time the maximum time to wait
* @param unit the time unit of the {@code time} argument
* @return {@code false} if the waiting time detectably elapsed
--- a/jdk/src/share/classes/java/util/concurrent/locks/Lock.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/locks/Lock.java Fri Oct 26 21:34:24 2012 +0100
@@ -77,14 +77,14 @@
* methods and statements. In most cases, the following idiom
* should be used:
*
- * <pre><tt> Lock l = ...;
- * l.lock();
- * try {
- * // access the resource protected by this lock
- * } finally {
- * l.unlock();
- * }
- * </tt></pre>
+ * <pre> {@code
+ * Lock l = ...;
+ * l.lock();
+ * try {
+ * // access the resource protected by this lock
+ * } finally {
+ * l.unlock();
+ * }}</pre>
*
* When locking and unlocking occur in different scopes, care must be
* taken to ensure that all code that is executed while the lock is
@@ -120,8 +120,9 @@
*
* <p>All {@code Lock} implementations <em>must</em> enforce the same
* memory synchronization semantics as provided by the built-in monitor
- * lock, as described in section 17.4 of
- * <cite>The Java™ Language Specification</cite>:
+ * lock, as described in
+ * <a href="http://docs.oracle.com/javase/specs/jls/se7/html/index.html">
+ * The Java Language Specification, Third Edition (17.4 Memory Model)</a>:
* <ul>
* <li>A successful {@code lock} operation has the same memory
* synchronization effects as a successful <em>Lock</em> action.
@@ -239,18 +240,18 @@
* immediately with the value {@code false}.
*
* <p>A typical usage idiom for this method would be:
- * <pre>
- * Lock lock = ...;
- * if (lock.tryLock()) {
- * try {
- * // manipulate protected state
- * } finally {
- * lock.unlock();
- * }
- * } else {
- * // perform alternative actions
- * }
- * </pre>
+ * <pre> {@code
+ * Lock lock = ...;
+ * if (lock.tryLock()) {
+ * try {
+ * // manipulate protected state
+ * } finally {
+ * lock.unlock();
+ * }
+ * } else {
+ * // perform alternative actions
+ * }}</pre>
+ *
* This usage ensures that the lock is unlocked if it was acquired, and
* doesn't try to unlock if the lock was not acquired.
*
--- a/jdk/src/share/classes/java/util/concurrent/locks/LockSupport.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/locks/LockSupport.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,10 +34,8 @@
*/
package java.util.concurrent.locks;
-import java.util.concurrent.*;
import sun.misc.Unsafe;
-
/**
* Basic thread blocking primitives for creating locks and other
* synchronization classes.
@@ -78,7 +76,10 @@
* higher-level synchronization utilities, and are not in themselves
* useful for most concurrency control applications. The {@code park}
* method is designed for use only in constructions of the form:
- * <pre>while (!canProceed()) { ... LockSupport.park(this); }</pre>
+ *
+ * <pre> {@code
+ * while (!canProceed()) { ... LockSupport.park(this); }}</pre>
+ *
* where neither {@code canProceed} nor any other actions prior to the
* call to {@code park} entail locking or blocking. Because only one
* permit is associated with each thread, any intermediary uses of
@@ -86,7 +87,7 @@
*
* <p><b>Sample Usage.</b> Here is a sketch of a first-in-first-out
* non-reentrant lock class:
- * <pre>{@code
+ * <pre> {@code
* class FIFOMutex {
* private final AtomicBoolean locked = new AtomicBoolean(false);
* private final Queue<Thread> waiters
@@ -116,7 +117,6 @@
* }
* }}</pre>
*/
-
public class LockSupport {
private LockSupport() {} // Cannot be instantiated.
--- a/jdk/src/share/classes/java/util/concurrent/locks/ReentrantLock.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/locks/ReentrantLock.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,9 +34,8 @@
*/
package java.util.concurrent.locks;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
+import java.util.concurrent.TimeUnit;
+import java.util.Collection;
/**
* A reentrant mutual exclusion {@link Lock} with the same basic
@@ -73,7 +72,7 @@
* follow a call to {@code lock} with a {@code try} block, most
* typically in a before/after construction such as:
*
- * <pre>
+ * <pre> {@code
* class X {
* private final ReentrantLock lock = new ReentrantLock();
* // ...
@@ -86,8 +85,7 @@
* lock.unlock()
* }
* }
- * }
- * </pre>
+ * }}</pre>
*
* <p>In addition to implementing the {@link Lock} interface, this
* class defines methods {@code isLocked} and
@@ -187,8 +185,7 @@
}
/**
- * Reconstitutes this lock instance from a stream.
- * @param s the stream
+ * Reconstitutes the instance from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
@@ -383,8 +380,11 @@
* method. If you want a timed {@code tryLock} that does permit barging on
* a fair lock then combine the timed and un-timed forms together:
*
- * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
- * </pre>
+ * <pre> {@code
+ * if (lock.tryLock() ||
+ * lock.tryLock(timeout, unit)) {
+ * ...
+ * }}</pre>
*
* <p>If the current thread
* already holds this lock then the hold count is incremented by one and
@@ -438,7 +438,6 @@
* the lock could be acquired
* @throws InterruptedException if the current thread is interrupted
* @throws NullPointerException if the time unit is null
- *
*/
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
@@ -514,7 +513,7 @@
* not be entered with the lock already held then we can assert that
* fact:
*
- * <pre>
+ * <pre> {@code
* class X {
* ReentrantLock lock = new ReentrantLock();
* // ...
@@ -527,8 +526,7 @@
* lock.unlock();
* }
* }
- * }
- * </pre>
+ * }}</pre>
*
* @return the number of holds on this lock by the current thread,
* or zero if this lock is not held by the current thread
@@ -545,7 +543,7 @@
* testing. For example, a method that should only be called while
* a lock is held can assert that this is the case:
*
- * <pre>
+ * <pre> {@code
* class X {
* ReentrantLock lock = new ReentrantLock();
* // ...
@@ -554,13 +552,12 @@
* assert lock.isHeldByCurrentThread();
* // ... method body
* }
- * }
- * </pre>
+ * }}</pre>
*
* <p>It can also be used to ensure that a reentrant lock is used
* in a non-reentrant manner, for example:
*
- * <pre>
+ * <pre> {@code
* class X {
* ReentrantLock lock = new ReentrantLock();
* // ...
@@ -574,8 +571,7 @@
* lock.unlock();
* }
* }
- * }
- * </pre>
+ * }}</pre>
*
* @return {@code true} if current thread holds this lock and
* {@code false} otherwise
@@ -636,7 +632,6 @@
return sync.hasQueuedThreads();
}
-
/**
* Queries whether the given thread is waiting to acquire this
* lock. Note that because cancellations may occur at any time, a
@@ -652,7 +647,6 @@
return sync.isQueued(thread);
}
-
/**
* Returns an estimate of the number of threads waiting to
* acquire this lock. The value is only an estimate because the number of
--- a/jdk/src/share/classes/java/util/concurrent/locks/ReentrantReadWriteLock.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/locks/ReentrantReadWriteLock.java Fri Oct 26 21:34:24 2012 +0100
@@ -34,9 +34,8 @@
*/
package java.util.concurrent.locks;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
-import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.Collection;
/**
* An implementation of {@link ReadWriteLock} supporting similar
@@ -62,7 +61,7 @@
* <dt><b><i>Fair mode</i></b>
* <dd> When constructed as fair, threads contend for entry using an
* approximately arrival-order policy. When the currently held lock
- * is released either the longest-waiting single writer thread will
+ * is released, either the longest-waiting single writer thread will
* be assigned the write lock, or if there is a group of reader threads
* waiting longer than all waiting writer threads, that group will be
* assigned the read lock.
@@ -80,8 +79,8 @@
* will block unless both the read lock and write lock are free (which
* implies there are no waiting threads). (Note that the non-blocking
* {@link ReadLock#tryLock()} and {@link WriteLock#tryLock()} methods
- * do not honor this fair setting and will acquire the lock if it is
- * possible, regardless of waiting threads.)
+ * do not honor this fair setting and will immediately acquire the lock
+ * if it is possible, regardless of waiting threads.)
* <p>
* </dl>
*
@@ -143,21 +142,21 @@
* void processCachedData() {
* rwl.readLock().lock();
* if (!cacheValid) {
- * // Must release read lock before acquiring write lock
- * rwl.readLock().unlock();
- * rwl.writeLock().lock();
- * try {
- * // Recheck state because another thread might have
- * // acquired write lock and changed state before we did.
- * if (!cacheValid) {
- * data = ...
- * cacheValid = true;
- * }
- * // Downgrade by acquiring read lock before releasing write lock
- * rwl.readLock().lock();
- * } finally {
- * rwl.writeLock().unlock(); // Unlock write, still hold read
- * }
+ * // Must release read lock before acquiring write lock
+ * rwl.readLock().unlock();
+ * rwl.writeLock().lock();
+ * try {
+ * // Recheck state because another thread might have
+ * // acquired write lock and changed state before we did.
+ * if (!cacheValid) {
+ * data = ...
+ * cacheValid = true;
+ * }
+ * // Downgrade by acquiring read lock before releasing write lock
+ * rwl.readLock().lock();
+ * } finally {
+ * rwl.writeLock().unlock(); // Unlock write, still hold read
+ * }
* }
*
* try {
@@ -176,33 +175,33 @@
* is a class using a TreeMap that is expected to be large and
* concurrently accessed.
*
- * <pre>{@code
+ * <pre> {@code
* class RWDictionary {
- * private final Map<String, Data> m = new TreeMap<String, Data>();
- * private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
- * private final Lock r = rwl.readLock();
- * private final Lock w = rwl.writeLock();
+ * private final Map<String, Data> m = new TreeMap<String, Data>();
+ * private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
+ * private final Lock r = rwl.readLock();
+ * private final Lock w = rwl.writeLock();
*
- * public Data get(String key) {
- * r.lock();
- * try { return m.get(key); }
- * finally { r.unlock(); }
- * }
- * public String[] allKeys() {
- * r.lock();
- * try { return m.keySet().toArray(); }
- * finally { r.unlock(); }
- * }
- * public Data put(String key, Data value) {
- * w.lock();
- * try { return m.put(key, value); }
- * finally { w.unlock(); }
- * }
- * public void clear() {
- * w.lock();
- * try { m.clear(); }
- * finally { w.unlock(); }
- * }
+ * public Data get(String key) {
+ * r.lock();
+ * try { return m.get(key); }
+ * finally { r.unlock(); }
+ * }
+ * public String[] allKeys() {
+ * r.lock();
+ * try { return m.keySet().toArray(); }
+ * finally { r.unlock(); }
+ * }
+ * public Data put(String key, Data value) {
+ * w.lock();
+ * try { return m.put(key, value); }
+ * finally { w.unlock(); }
+ * }
+ * public void clear() {
+ * w.lock();
+ * try { m.clear(); }
+ * finally { w.unlock(); }
+ * }
* }}</pre>
*
* <h3>Implementation Notes</h3>
@@ -213,7 +212,6 @@
*
* @since 1.5
* @author Doug Lea
- *
*/
public class ReentrantReadWriteLock
implements ReadWriteLock, java.io.Serializable {
@@ -654,8 +652,7 @@
}
/**
- * Reconstitute this lock instance from a stream
- * @param s the stream
+ * Reconstitutes the instance from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
@@ -799,7 +796,7 @@
*
* @return {@code true} if the read lock was acquired
*/
- public boolean tryLock() {
+ public boolean tryLock() {
return sync.tryReadLock();
}
@@ -819,8 +816,11 @@
* permit barging on a fair lock then combine the timed and
* un-timed forms together:
*
- * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
- * </pre>
+ * <pre> {@code
+ * if (lock.tryLock() ||
+ * lock.tryLock(timeout, unit)) {
+ * ...
+ * }}</pre>
*
* <p>If the write lock is held by another thread then the
* current thread becomes disabled for thread scheduling
@@ -866,7 +866,6 @@
* @return {@code true} if the read lock was acquired
* @throws InterruptedException if the current thread is interrupted
* @throws NullPointerException if the time unit is null
- *
*/
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
@@ -879,7 +878,7 @@
* <p> If the number of readers is now zero then the lock
* is made available for write lock attempts.
*/
- public void unlock() {
+ public void unlock() {
sync.releaseShared(1);
}
@@ -1049,8 +1048,11 @@
* that does permit barging on a fair lock then combine the
* timed and un-timed forms together:
*
- * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
- * </pre>
+ * <pre> {@code
+ * if (lock.tryLock() ||
+ * lock.tryLock(timeout, unit)) {
+ * ...
+ * }}</pre>
*
* <p>If the current thread already holds this lock then the
* hold count is incremented by one and the method returns
@@ -1108,7 +1110,6 @@
*
* @throws InterruptedException if the current thread is interrupted
* @throws NullPointerException if the time unit is null
- *
*/
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
--- a/jdk/src/share/classes/java/util/concurrent/package-info.java Fri Oct 26 11:21:02 2012 +0100
+++ b/jdk/src/share/classes/java/util/concurrent/package-info.java Fri Oct 26 21:34:24 2012 +0100
@@ -188,7 +188,7 @@
* A {@code CopyOnWriteArrayList} is preferable to a synchronized
* {@code ArrayList} when the expected number of reads and traversals
* greatly outnumber the number of updates to a list.
-
+ *
* <p>The "Concurrent" prefix used with some classes in this package
* is a shorthand indicating several differences from similar
* "synchronized" classes. For example {@code java.util.Hashtable} and
@@ -218,9 +218,8 @@
*
* <h2><a name="MemoryVisibility">Memory Consistency Properties</a></h2>
*
- * Chapter 17 of
- * <cite>The Java™ Language Specification</cite>
- * defines the
+ * <a href="http://docs.oracle.com/javase/specs/jls/se7/html/index.html">
+ * Chapter 17 of the Java Language Specification</a> defines the
* <i>happens-before</i> relation on memory operations such as reads and
* writes of shared variables. The results of a write by one thread are
* guaranteed to be visible to a read by another thread only if the write