--- jsr166/src/jsr166y/Phaser.java 2008/10/28 23:03:24 1.6 +++ jsr166/src/jsr166y/Phaser.java 2009/07/23 19:25:45 1.17 @@ -5,6 +5,7 @@ */ package jsr166y; + import java.util.concurrent.*; import java.util.concurrent.atomic.*; import java.util.concurrent.locks.LockSupport; @@ -13,9 +14,9 @@ import java.lang.reflect.*; /** * A reusable synchronization barrier, similar in functionality to a - * {@link java.util.concurrent.CyclicBarrier} and {@link - * java.util.concurrent.CountDownLatch} but supporting more flexible - * usage. + * {@link java.util.concurrent.CyclicBarrier CyclicBarrier} and + * {@link java.util.concurrent.CountDownLatch CountDownLatch} + * but supporting more flexible usage. * *
Sample usages: * - *
A Phaser may be used instead of a CountdownLatch to control + *
A Phaser may be used instead of a {@code CountDownLatch} to control * a one-shot action serving a variable number of parties. The typical * idiom is for the method setting this up to first register, then * start the actions, then deregister, as in: * - *
- * void runTasks(List<Runnable> list) { - * final Phaser phaser = new Phaser(1); // "1" to register self - * for (Runnable r : list) { - * phaser.register(); - * new Thread() { - * public void run() { - * phaser.arriveAndAwaitAdvance(); // await all creation - * r.run(); - * phaser.arriveAndDeregister(); // signal completion - * } - * }.start(); + ** *{@code + * void runTasks(List+ * phaser.awaitAdvance(p); // await final completion + * }}list) { + * final Phaser phaser = new Phaser(1); // "1" to register self + * for (Runnable r : list) { + * phaser.register(); + * new Thread() { + * public void run() { + * phaser.arriveAndAwaitAdvance(); // await all creation + * r.run(); + * phaser.arriveAndDeregister(); // signal completion + * } + * }.start(); * } * * doSomethingOnBehalfOfWorkers(); @@ -108,62 +112,58 @@ import java.lang.reflect.*; * int p = phaser.arriveAndDeregister(); // deregister self ... * p = phaser.awaitAdvance(p); // ... and await arrival * otherActions(); // do other things while tasks execute - * phaser.awaitAdvance(p); // awit final completion - * } - *
One way to cause a set of threads to repeatedly perform actions - * for a given number of iterations is to override onAdvance: + * for a given number of iterations is to override {@code onAdvance}: * - *
- * void startTasks(List<Runnable> list, final int iterations) { - * final Phaser phaser = new Phaser() { - * public boolean onAdvance(int phase, int registeredParties) { - * return phase >= iterations || registeredParties == 0; + ** *{@code + * void startTasks(List+ * }}list, final int iterations) { + * final Phaser phaser = new Phaser() { + * public boolean onAdvance(int phase, int registeredParties) { + * return phase >= iterations || registeredParties == 0; + * } + * }; + * phaser.register(); + * for (Runnable r : list) { + * phaser.register(); + * new Thread() { + * public void run() { + * do { + * r.run(); + * phaser.arriveAndAwaitAdvance(); + * } while(!phaser.isTerminated(); * } - * }; - * phaser.register(); - * for (Runnable r : list) { - * phaser.register(); - * new Thread() { - * public void run() { - * do { - * r.run(); - * phaser.arriveAndAwaitAdvance(); - * } while(!phaser.isTerminated(); - * } - * }.start(); + * }.start(); * } * phaser.arriveAndDeregister(); // deregister self, don't wait - * } - *
To create a set of tasks using a tree of Phasers, * you could use code of the following form, assuming a * Task class with a constructor accepting a Phaser that * it registers for upon construction: - *
- * void build(Task[] actions, int lo, int hi, Phaser b) { - * int step = (hi - lo) / TASKS_PER_PHASER; - * if (step > 1) { - * int i = lo; - * while (i < hi) { - * int r = Math.min(i + step, hi); - * build(actions, i, r, new Phaser(b)); - * i = r; - * } - * } - * else { - * for (int i = lo; i < hi; ++i) - * actions[i] = new Task(b); - * // assumes new Task(b) performs b.register() - * } - * } - * // .. initially called, for n tasks via - * build(new Task[n], 0, n, new Phaser()); - *+ *
{@code + * void build(Task[] actions, int lo, int hi, Phaser b) { + * int step = (hi - lo) / TASKS_PER_PHASER; + * if (step > 1) { + * int i = lo; + * while (i < hi) { + * int r = Math.min(i + step, hi); + * build(actions, i, r, new Phaser(b)); + * i = r; + * } + * } else { + * for (int i = lo; i < hi; ++i) + * actions[i] = new Task(b); + * // assumes new Task(b) performs b.register() + * } + * } + * // .. initially called, for n tasks via + * build(new Task[n], 0, n, new Phaser());}* - * The best value of TASKS_PER_PHASER depends mainly on + * The best value of {@code TASKS_PER_PHASER} depends mainly on * expected barrier synchronization rates. A value as low as four may * be appropriate for extremely small per-barrier task bodies (thus * high rates), or up to hundreds for extremely large ones. @@ -175,6 +175,9 @@ import java.lang.reflect.*; * parties result in IllegalStateExceptions. However, you can and * should create tiered phasers to accommodate arbitrarily large sets * of participants. + * + * @since 1.7 + * @author Doug Lea */ public class Phaser { /* @@ -195,28 +198,28 @@ public class Phaser { * However, to efficiently maintain atomicity, these values are * packed into a single (atomic) long. Termination uses the sign * bit of 32 bit representation of phase, so phase is set to -1 on - * termination. Good performace relies on keeping state decoding + * termination. Good performance relies on keeping state decoding * and encoding simple, and keeping race windows short. * * Note: there are some cheats in arrive() that rely on unarrived - * being lowest 16 bits. + * count being lowest 16 bits. */ private volatile long state; private static final int ushortBits = 16; - private static final int ushortMask = (1 << ushortBits) - 1; - private static final int phaseMask = 0x7fffffff; + private static final int ushortMask = 0xffff; + private static final int phaseMask = 0x7fffffff; private static int unarrivedOf(long s) { return (int)(s & ushortMask); } private static int partiesOf(long s) { - return (int)(s & (ushortMask << 16)) >>> 16; + return ((int) s) >>> 16; } private static int phaseOf(long s) { - return (int)(s >>> 32); + return (int) (s >>> 32); } private static int arrivedOf(long s) { @@ -224,17 +227,21 @@ public class Phaser { } private static long stateFor(int phase, int parties, int unarrived) { - return (((long)phase) << 32) | ((parties << 16) | unarrived); + return ((((long) phase) << 32) | (((long) parties) << 16) | + (long) unarrived); } private static long trippedStateFor(int phase, int parties) { - return (((long)phase) << 32) | ((parties << 16) | parties); + long lp = (long) parties; + return (((long) phase) << 32) | (lp << 16) | lp; } - private static IllegalStateException badBounds(int parties, int unarrived) { - return new IllegalStateException - ("Attempt to set " + unarrived + - " unarrived of " + parties + " parties"); + /** + * Returns message string for bad bounds exceptions. + */ + private static String badBounds(int parties, int unarrived) { + return ("Attempt to set " + unarrived + + " unarrived of " + parties + " parties"); } /** @@ -251,7 +258,7 @@ public class Phaser { // Wait queues /** - * Heads of Treiber stacks waiting for nonFJ threads. To eliminate + * Heads of Treiber stacks for waiting threads. To eliminate * contention while releasing some threads while adding others, we * use two of them, alternating across even and odd phases. */ @@ -295,7 +302,8 @@ public class Phaser { /** * Creates a new Phaser without any initially registered parties, - * initial phase number 0, and no parent. + * initial phase number 0, and no parent. Any thread using this + * Phaser will need to first register for it. */ public Phaser() { this(null); @@ -304,9 +312,10 @@ public class Phaser { /** * Creates a new Phaser with the given numbers of registered * unarrived parties, initial phase number 0, and no parent. - * @param parties the number of parties required to trip barrier. + * + * @param parties the number of parties required to trip barrier * @throws IllegalArgumentException if parties less than zero - * or greater than the maximum number of parties supported. + * or greater than the maximum number of parties supported */ public Phaser(int parties) { this(null, parties); @@ -317,7 +326,8 @@ public class Phaser { * initially registered parties. If parent is non-null this phaser * is registered with the parent and its initial phase number is * the same as that of parent phaser. - * @param parent the parent phaser. + * + * @param parent the parent phaser */ public Phaser(Phaser parent) { int phase = 0; @@ -333,13 +343,14 @@ public class Phaser { /** * Creates a new Phaser with the given parent and numbers of - * registered unarrived parties. If parent is non-null this phaser + * registered unarrived parties. If parent is non-null, this phaser * is registered with the parent and its initial phase number is * the same as that of parent phaser. - * @param parent the parent phaser. - * @param parties the number of parties required to trip barrier. + * + * @param parent the parent phaser + * @param parties the number of parties required to trip barrier * @throws IllegalArgumentException if parties less than zero - * or greater than the maximum number of parties supported. + * or greater than the maximum number of parties supported */ public Phaser(Phaser parent, int parties) { if (parties < 0 || parties > ushortMask) @@ -357,9 +368,10 @@ public class Phaser { /** * Adds a new unarrived party to this phaser. + * * @return the current barrier phase number upon registration * @throws IllegalStateException if attempting to register more - * than the maximum supported number of parties. + * than the maximum supported number of parties */ public int register() { return doRegister(1); @@ -367,10 +379,11 @@ public class Phaser { /** * Adds the given number of new unarrived parties to this phaser. - * @param parties the number of parties required to trip barrier. + * + * @param parties the number of parties required to trip barrier * @return the current barrier phase number upon registration * @throws IllegalStateException if attempting to register more - * than the maximum supported number of parties. + * than the maximum supported number of parties */ public int bulkRegister(int parties) { if (parties < 0) @@ -393,7 +406,7 @@ public class Phaser { if (phase < 0) break; if (parties > ushortMask || unarrived > ushortMask) - throw badBounds(parties, unarrived); + throw new IllegalStateException(badBounds(parties, unarrived)); if (phase == phaseOf(root.state) && casState(s, stateFor(phase, parties, unarrived))) break; @@ -406,15 +419,17 @@ public class Phaser { * in turn wait for others via {@link #awaitAdvance}). * * @return the barrier phase number upon entry to this method, or a - * negative value if terminated; + * negative value if terminated * @throws IllegalStateException if not terminated and the number - * of unarrived parties would become negative. + * of unarrived parties would become negative */ public int arrive() { int phase; for (;;) { long s = state; phase = phaseOf(s); + if (phase < 0) + break; int parties = partiesOf(s); int unarrived = unarrivedOf(s) - 1; if (unarrived > 0) { // Not the last arrival @@ -440,12 +455,10 @@ public class Phaser { } } } - else if (phase < 0) // Don't throw exception if terminated - break; else if (phase != phaseOf(root.state)) // or if unreconciled reconcileState(); else - throw badBounds(parties, unarrived); + throw new IllegalStateException(badBounds(parties, unarrived)); } return phase; } @@ -458,9 +471,9 @@ public class Phaser { * zero parties, this phaser is also deregistered from its parent. * * @return the current barrier phase number upon entry to - * this method, or a negative value if terminated; + * this method, or a negative value if terminated * @throws IllegalStateException if not terminated and the number - * of registered or unarrived parties would become negative. + * of registered or unarrived parties would become negative */ public int arriveAndDeregister() { // similar code to arrive, but too different to merge @@ -469,6 +482,8 @@ public class Phaser { for (;;) { long s = state; phase = phaseOf(s); + if (phase < 0) + break; int parties = partiesOf(s) - 1; int unarrived = unarrivedOf(s) - 1; if (parties >= 0) { @@ -494,26 +509,25 @@ public class Phaser { } continue; } - if (phase < 0) - break; if (par != null && phase != phaseOf(root.state)) { reconcileState(); continue; } } - throw badBounds(parties, unarrived); + throw new IllegalStateException(badBounds(parties, unarrived)); } return phase; } /** * Arrives at the barrier and awaits others. Equivalent in effect - * to awaitAdvance(arrive()). If you instead need to + * to {@code awaitAdvance(arrive())}. If you instead need to * await with interruption of timeout, and/or deregister upon * arrival, you can arrange them using analogous constructions. + * * @return the phase on entry to this method * @throws IllegalStateException if not terminated and the number - * of unarrived parties would become negative. + * of unarrived parties would become negative */ public int arriveAndAwaitAdvance() { return awaitAdvance(arrive()); @@ -523,6 +537,7 @@ public class Phaser { * Awaits the phase of the barrier to advance from the given * value, or returns immediately if argument is negative or this * barrier is terminated. + * * @param phase the phase on entry to this method * @return the phase on exit from this method */ @@ -533,7 +548,7 @@ public class Phaser { int p = phaseOf(s); if (p != phase) return p; - if (unarrivedOf(s) == 0) + if (unarrivedOf(s) == 0 && parent != null) parent.awaitAdvance(phase); // Fall here even if parent waited, to reconcile and help release return untimedWait(phase); @@ -541,21 +556,23 @@ public class Phaser { /** * Awaits the phase of the barrier to advance from the given - * value, or returns immediately if argumet is negative or this + * value, or returns immediately if argument is negative or this * barrier is terminated, or throws InterruptedException if * interrupted while waiting. + * * @param phase the phase on entry to this method * @return the phase on exit from this method * @throws InterruptedException if thread interrupted while waiting */ - public int awaitAdvanceInterruptibly(int phase) throws InterruptedException { + public int awaitAdvanceInterruptibly(int phase) + throws InterruptedException { if (phase < 0) return phase; long s = getReconciledState(); int p = phaseOf(s); if (p != phase) return p; - if (unarrivedOf(s) != 0) + if (unarrivedOf(s) == 0 && parent != null) parent.awaitAdvanceInterruptibly(phase); return interruptibleWait(phase); } @@ -564,6 +581,7 @@ public class Phaser { * Awaits the phase of the barrier to advance from the given value * or the given timeout elapses, or returns immediately if * argument is negative or this barrier is terminated. + * * @param phase the phase on entry to this method * @return the phase on exit from this method * @throws InterruptedException if thread interrupted while waiting @@ -577,7 +595,7 @@ public class Phaser { int p = phaseOf(s); if (p != phase) return p; - if (unarrivedOf(s) == 0) + if (unarrivedOf(s) == 0 && parent != null) parent.awaitAdvanceInterruptibly(phase, timeout, unit); return timedWait(phase, unit.toNanos(timeout)); } @@ -608,8 +626,9 @@ public class Phaser { /** * Returns the current phase number. The maximum phase number is - * Integer.MAX_VALUE, after which it restarts at + * {@code Integer.MAX_VALUE}, after which it restarts at * zero. Upon termination, the phase number is negative. + * * @return the phase number, or a negative value if terminated */ public final int getPhase() { @@ -617,9 +636,10 @@ public class Phaser { } /** - * Returns true if the current phase number equals the given phase. + * Returns {@code true} if the current phase number equals the given phase. + * * @param phase the phase - * @return true if the current phase number equals the given phase. + * @return {@code true} if the current phase number equals the given phase */ public final boolean hasPhase(int phase) { return phaseOf(getReconciledState()) == phase; @@ -627,6 +647,7 @@ public class Phaser { /** * Returns the number of parties registered at this barrier. + * * @return the number of parties */ public int getRegisteredParties() { @@ -636,6 +657,7 @@ public class Phaser { /** * Returns the number of parties that have arrived at the current * phase of this barrier. + * * @return the number of arrived parties */ public int getArrivedParties() { @@ -645,6 +667,7 @@ public class Phaser { /** * Returns the number of registered parties that have not yet * arrived at the current phase of this barrier. + * * @return the number of unarrived parties */ public int getUnarrivedParties() { @@ -653,7 +676,8 @@ public class Phaser { /** * Returns the parent of this phaser, or null if none. - * @return the parent of this phaser, or null if none. + * + * @return the parent of this phaser, or null if none */ public Phaser getParent() { return parent; @@ -662,15 +686,17 @@ public class Phaser { /** * Returns the root ancestor of this phaser, which is the same as * this phaser if it has no parent. - * @return the root ancestor of this phaser. + * + * @return the root ancestor of this phaser */ public Phaser getRoot() { return root; } /** - * Returns true if this barrier has been terminated. - * @return true if this barrier has been terminated + * Returns {@code true} if this barrier has been terminated. + * + * @return {@code true} if this barrier has been terminated */ public boolean isTerminated() { return getPhase() < 0; @@ -682,7 +708,7 @@ public class Phaser { * barrier is tripped (and thus all other waiting parties are * dormant). If it returns true, then, rather than advance the * phase number, this barrier will be set to a final termination - * state, and subsequent calls to isTerminated will + * state, and subsequent calls to {@code isTerminated} will * return true. * *
The default version returns true when the number of @@ -693,7 +719,7 @@ public class Phaser { *
You may override this method to perform an action with side
* effects visible to participating tasks, but it is in general
* only sensible to do so in designs where all parties register
- * before any arrive, and all awaitAdvance at each phase.
+ * before any arrive, and all {@code awaitAdvance} at each phase.
* Otherwise, you cannot ensure lack of interference. In
* particular, this method may be invoked more than once per
* transition if other parties successfully register while the
@@ -702,9 +728,8 @@ public class Phaser {
* method.
*
* @param phase the phase number on entering the barrier
- * @param registeredParties the current number of registered
- * parties.
- * @return true if this barrier should terminate
+ * @param registeredParties the current number of registered parties
+ * @return {@code true} if this barrier should terminate
*/
protected boolean onAdvance(int phase, int registeredParties) {
return registeredParties <= 0;
@@ -713,51 +738,67 @@ public class Phaser {
/**
* Returns a string identifying this phaser, as well as its
* state. The state, in brackets, includes the String {@code
- * "phase ="} followed by the phase number, {@code "parties ="}
+ * "phase = "} followed by the phase number, {@code "parties = "}
* followed by the number of registered parties, and {@code
- * "arrived ="} followed by the number of arrived parties
+ * "arrived = "} followed by the number of arrived parties.
*
* @return a string identifying this barrier, as well as its state
*/
public String toString() {
long s = getReconciledState();
- return super.toString() + "[phase = " + phaseOf(s) + " parties = " + partiesOf(s) + " arrived = " + arrivedOf(s) + "]";
+ return super.toString() +
+ "[phase = " + phaseOf(s) +
+ " parties = " + partiesOf(s) +
+ " arrived = " + arrivedOf(s) + "]";
}
// methods for waiting
- /** The number of CPUs, for spin control */
- static final int NCPUS = Runtime.getRuntime().availableProcessors();
-
- /**
- * The number of times to spin before blocking in timed waits.
- * The value is empirically derived.
- */
- static final int maxTimedSpins = (NCPUS < 2)? 0 : 32;
-
- /**
- * The number of times to spin before blocking in untimed waits.
- * This is greater than timed value because untimed waits spin
- * faster since they don't need to check times on each spin.
- */
- static final int maxUntimedSpins = maxTimedSpins * 32;
-
- /**
- * The number of nanoseconds for which it is faster to spin
- * rather than to use timed park. A rough estimate suffices.
- */
- static final long spinForTimeoutThreshold = 1000L;
-
/**
- * Wait nodes for Treiber stack representing wait queue for non-FJ
- * tasks.
+ * Wait nodes for Treiber stack representing wait queue
*/
- static final class QNode {
- QNode next;
+ static final class QNode implements ForkJoinPool.ManagedBlocker {
+ final Phaser phaser;
+ final int phase;
+ final long startTime;
+ final long nanos;
+ final boolean timed;
+ final boolean interruptible;
+ volatile boolean wasInterrupted = false;
volatile Thread thread; // nulled to cancel wait
- QNode() {
+ QNode next;
+ QNode(Phaser phaser, int phase, boolean interruptible,
+ boolean timed, long startTime, long nanos) {
+ this.phaser = phaser;
+ this.phase = phase;
+ this.timed = timed;
+ this.interruptible = interruptible;
+ this.startTime = startTime;
+ this.nanos = nanos;
thread = Thread.currentThread();
}
+ public boolean isReleasable() {
+ return (thread == null ||
+ phaser.getPhase() != phase ||
+ (interruptible && wasInterrupted) ||
+ (timed && (nanos - (System.nanoTime() - startTime)) <= 0));
+ }
+ public boolean block() {
+ if (Thread.interrupted()) {
+ wasInterrupted = true;
+ if (interruptible)
+ return true;
+ }
+ if (!timed)
+ LockSupport.park(this);
+ else {
+ long waitTime = nanos - (System.nanoTime() - startTime);
+ if (waitTime <= 0)
+ return true;
+ LockSupport.parkNanos(this, waitTime);
+ }
+ return isReleasable();
+ }
void signal() {
Thread t = thread;
if (t != null) {
@@ -765,10 +806,20 @@ public class Phaser {
LockSupport.unpark(t);
}
}
+ boolean doWait() {
+ if (thread != null) {
+ try {
+ ForkJoinPool.managedBlock(this, false);
+ } catch (InterruptedException ie) {
+ }
+ }
+ return wasInterrupted;
+ }
+
}
/**
- * Removes and signals waiting threads from wait queue
+ * Removes and signals waiting threads from wait queue.
*/
private void releaseWaiters(int phase) {
AtomicReference