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: @@ -102,15 +106,18 @@ import java.lang.reflect.*; * } * }.start(); * } + * + * doSomethingOnBehalfOfWorkers(); * phaser.arrive(); // allow threads to start - * int p = phaser.arriveAndDeregister(); // deregister self + * int p = phaser.arriveAndDeregister(); // deregister self ... + * p = phaser.awaitAdvance(p); // ... and await arrival * otherActions(); // do other things while tasks execute - * phaser.awaitAdvance(p); // wait for all tasks to arrive + * phaser.awaitAdvance(p); // await 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) {
@@ -160,7 +167,7 @@ import java.lang.reflect.*;
* 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.
@@ -192,24 +199,24 @@ 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) {
@@ -221,17 +228,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");
}
/**
@@ -248,7 +259,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.
*/
@@ -292,7 +303,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);
@@ -390,7 +402,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;
@@ -412,6 +424,8 @@ public class Phaser {
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
@@ -437,12 +451,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;
}
@@ -466,6 +478,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) {
@@ -491,21 +505,19 @@ 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
@@ -530,7 +542,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);
@@ -538,21 +550,22 @@ 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);
}
@@ -574,7 +587,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));
}
@@ -605,7 +618,7 @@ 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
*/
@@ -614,9 +627,9 @@ 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;
@@ -650,7 +663,7 @@ 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;
@@ -659,15 +672,15 @@ 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;
@@ -679,7 +692,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 @@ -690,7 +703,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
@@ -699,9 +712,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;
@@ -710,51 +722,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.
+ * Wait nodes for Treiber stack representing wait queue
*/
- static final long spinForTimeoutThreshold = 1000L;
-
- /**
- * Wait nodes for Treiber stack representing wait queue for non-FJ
- * tasks.
- */
- 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) {
@@ -762,6 +790,16 @@ public class Phaser {
LockSupport.unpark(t);
}
}
+ boolean doWait() {
+ if (thread != null) {
+ try {
+ ForkJoinPool.managedBlock(this, false);
+ } catch (InterruptedException ie) {
+ }
+ }
+ return wasInterrupted;
+ }
+
}
/**
@@ -777,132 +815,141 @@ public class Phaser {
}
/**
+ * Tries to enqueue given node in the appropriate wait queue
+ * @return true if successful
+ */
+ private boolean tryEnqueue(QNode node) {
+ AtomicReference