--- jsr166/src/jsr166y/Phaser.java 2010/11/27 16:46:53 1.59 +++ jsr166/src/jsr166y/Phaser.java 2010/11/29 20:58:06 1.64 @@ -34,38 +34,38 @@ import java.util.concurrent.locks.LockSu * Phaser} may be repeatedly awaited. Method {@link * #arriveAndAwaitAdvance} has effect analogous to {@link * java.util.concurrent.CyclicBarrier#await CyclicBarrier.await}. Each - * generation of a {@code Phaser} has an associated phase number. The - * phase number starts at zero, and advances when all parties arrive - * at the barrier, wrapping around to zero after reaching {@code + * generation of a phaser has an associated phase number. The phase + * number starts at zero, and advances when all parties arrive at the + * phaser, wrapping around to zero after reaching {@code * Integer.MAX_VALUE}. The use of phase numbers enables independent - * control of actions upon arrival at a barrier and upon awaiting + * control of actions upon arrival at a phaser and upon awaiting * others, via two kinds of methods that may be invoked by any * registered party: * * * - *

Termination. A {@code Phaser} may enter a - * termination state in which all synchronization methods - * immediately return without updating phaser state or waiting for - * advance, and indicating (via a negative phase value) that execution - * is complete. Termination is triggered when an invocation of {@code - * onAdvance} returns {@code true}. The default implementation returns - * {@code true} if a deregistration has caused the number of - * registered parties to become zero. As illustrated below, when - * phasers control actions with a fixed number of iterations, it is - * often convenient to override this method to cause termination when - * the current phase number reaches a threshold. Method {@link - * #forceTermination} is also available to abruptly release waiting - * threads and allow them to terminate. + *

Termination. A phaser may enter a termination + * state in which all synchronization methods immediately return + * without updating phaser state or waiting for advance, and + * indicating (via a negative phase value) that execution is complete. + * Termination is triggered when an invocation of {@code onAdvance} + * returns {@code true}. The default implementation returns {@code + * true} if a deregistration has caused the number of registered + * parties to become zero. As illustrated below, when phasers control + * actions with a fixed number of iterations, it is often convenient + * to override this method to cause termination when the current phase + * number reaches a threshold. Method {@link #forceTermination} is + * also available to abruptly release waiting threads and allow them + * to terminate. * *

Tiering. Phasers may be tiered (i.e., * constructed in tree structures) to reduce contention. Phasers with @@ -185,7 +185,7 @@ import java.util.concurrent.locks.LockSu * *

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 + * Task class with a constructor accepting a {@code Phaser} that * it registers with upon construction: * * 

 {@code
@@ -205,8 +205,8 @@ import java.util.concurrent.locks.LockSu
  * build(new Task[n], 0, n, new Phaser());}
* * 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 + * expected synchronization rates. A value as low as four may + * be appropriate for extremely small per-phase task bodies (thus * high rates), or up to hundreds for extremely large ones. * *

Implementation notes: This implementation restricts the @@ -226,8 +226,7 @@ public class Phaser { */ /** - * Barrier state representation. Conceptually, a barrier contains - * four values: + * Primary state representation, holding four fields: * * * unarrived -- the number of parties yet to hit barrier (bits 0-15) * * parties -- the number of parties to wait (bits 16-31) @@ -347,11 +346,11 @@ public class Phaser { else { parent.doArrive((u == 0) ? ONE_ARRIVAL|ONE_PARTY : ONE_ARRIVAL); - if ((int)(parent.state >>> PHASE_SHIFT) != nextPhase || - ((int)(state >>> PHASE_SHIFT) != nextPhase && - !UNSAFE.compareAndSwapLong(this, stateOffset, - s, next))) + if ((int)(parent.state >>> PHASE_SHIFT) != nextPhase) reconcileState(); + else if (state == s) + UNSAFE.compareAndSwapLong(this, stateOffset, s, + next); } } return phase; @@ -383,9 +382,9 @@ public class Phaser { return phase; } else if (parties != 0) // wait for onAdvance - internalAwaitAdvance(phase, null); + root.internalAwaitAdvance(phase, null); else { // 1st registration of child - synchronized(this) { // register parent first + synchronized (this) { // register parent first if (reconcileState() == s) { // recheck under lock parent.doRegister(1); // OK if throws IllegalState for (;;) { // simpler form of outer loop @@ -413,7 +412,7 @@ public class Phaser { int phase, rPhase; while ((phase = (int)(s >>> PHASE_SHIFT)) >= 0 && (rPhase = (int)(rt.state >>> PHASE_SHIFT)) != phase) { - if ((int)(par.state >>> PHASE_SHIFT) != rPhase) + if (par != rt && (int)(par.state >>> PHASE_SHIFT) != rPhase) par.reconcileState(); else if (rPhase < 0 || ((int)s & UNARRIVED_MASK) == 0) { long u = s & PARTIES_MASK; // reset unarrived to parties @@ -428,8 +427,8 @@ public class Phaser { } /** - * Creates a new phaser without any initially registered parties, - * initial phase number 0, and no parent. Any thread using this + * Creates a new phaser with no initially registered parties, no + * parent, and initial phase number 0. Any thread using this * phaser will need to first register for it. */ public Phaser() { @@ -438,9 +437,10 @@ public class Phaser { /** * Creates a new phaser with the given number of registered - * unarrived parties, initial phase number 0, and no parent. + * unarrived parties, no parent, and initial phase number 0. * - * @param parties the number of parties required to trip barrier + * @param parties the number of parties required to advance to the + * next phase * @throws IllegalArgumentException if parties less than zero * or greater than the maximum number of parties supported */ @@ -449,12 +449,6 @@ public class Phaser { } /** - * Creates a new phaser with the given parent, and without any - * initially registered parties. Any thread using this phaser - * will need to first register for it, at which point, if the - * given parent is non-null, this phaser will also be registered - * with the parent. - * * Equivalent to {@link #Phaser(Phaser, int) Phaser(parent, 0)}. * * @param parent the parent phaser @@ -465,44 +459,49 @@ public class Phaser { /** * Creates a new phaser with the given parent and number of - * registered unarrived parties. If parent is non-null and - * the number of parties is non-zero, this phaser is registered - * with the parent. + * registered unarrived parties. Registration and deregistration + * of this child phaser with its parent are managed automatically. + * If the given parent is non-null, whenever this child phaser has + * any registered parties (as established in this constructor, + * {@link #register}, or {@link #bulkRegister}), this child phaser + * is registered with its parent. Whenever the number of + * registered parties becomes zero as the result of an invocation + * of {@link #arriveAndDeregister}, this child phaser is + * deregistered from its parent. * * @param parent the parent phaser - * @param parties the number of parties required to trip barrier + * @param parties the number of parties required to advance to the + * next phase * @throws IllegalArgumentException if parties less than zero * or greater than the maximum number of parties supported */ public Phaser(Phaser parent, int parties) { if (parties >>> PARTIES_SHIFT != 0) throw new IllegalArgumentException("Illegal number of parties"); - int phase; + long s = ((long) parties) | (((long) parties) << PARTIES_SHIFT); this.parent = parent; if (parent != null) { Phaser r = parent.root; this.root = r; this.evenQ = r.evenQ; this.oddQ = r.oddQ; - phase = (parties == 0) ? parent.getPhase() : parent.doRegister(1); + if (parties != 0) + s |= ((long)(parent.doRegister(1))) << PHASE_SHIFT; } else { this.root = this; this.evenQ = new AtomicReference(); this.oddQ = new AtomicReference(); - phase = 0; } - long p = (long)parties; - this.state = (((long)phase) << PHASE_SHIFT) | p | (p << PARTIES_SHIFT); + this.state = s; } /** * Adds a new unarrived party to this phaser. If an ongoing * invocation of {@link #onAdvance} is in progress, this method - * may wait until its completion before registering. If this - * phaser has a parent, and this phaser previously had no - * registered parties, this phaser is also registered with its - * parent. + * may await its completion before returning. If this phaser has + * a parent, and this phaser previously had no registered parties, + * this phaser is also registered with its parent. * * @return the arrival phase number to which this registration applied * @throws IllegalStateException if attempting to register more @@ -515,13 +514,13 @@ public class Phaser { /** * Adds the given number of new unarrived parties to this phaser. * If an ongoing invocation of {@link #onAdvance} is in progress, - * this method may wait until its completion before registering. - * If this phaser has a parent, and the given number of parities - * is greater than zero, and this phaser previously had no - * registered parties, this phaser is also registered with its - * parent. + * this method may await its completion before returning. If this + * phaser has a parent, and the given number of parities is + * greater than zero, and this phaser previously had no registered + * parties, this phaser is also registered with its parent. * - * @param parties the number of additional parties required to trip barrier + * @param parties the number of additional parties required to + * advance to the next phase * @return the arrival phase number to which this registration applied * @throws IllegalStateException if attempting to register more * than the maximum supported number of parties @@ -530,18 +529,18 @@ public class Phaser { public int bulkRegister(int parties) { if (parties < 0) throw new IllegalArgumentException(); - else if (parties == 0) + if (parties == 0) return getPhase(); return doRegister(parties); } /** - * Arrives at the barrier, but does not wait for others. (You can - * in turn wait for others via {@link #awaitAdvance}). It is a - * usage error for an unregistered party to invoke this - * method. However, it is possible that this error will result in - * an {code IllegalStateException} only when some other - * party arrives. + * Arrives at this phaser, without waiting for others to arrive. + * + *

It is a usage error for an unregistered party to invoke this + * method. However, this error may result in an {@code + * IllegalStateException} only upon some subsequent operation on + * this phaser, if ever. * * @return the arrival phase number, or a negative value if terminated * @throws IllegalStateException if not terminated and the number @@ -552,15 +551,16 @@ public class Phaser { } /** - * Arrives at the barrier and deregisters from it without waiting - * for others. Deregistration reduces the number of parties - * required to trip the barrier in future phases. If this phaser + * Arrives at this phaser and deregisters from it without waiting + * for others to arrive. Deregistration reduces the number of + * parties required to advance in future phases. If this phaser * has a parent, and deregistration causes this phaser to have - * zero parties, this phaser also arrives at and is deregistered - * from its parent. It is a usage error for an unregistered party - * to invoke this method. However, it is possible that this error - * will result in an {code IllegalStateException} only when some - * other party arrives. + * zero parties, this phaser is also deregistered from its parent. + * + *

It is a usage error for an unregistered party to invoke this + * method. However, this error may result in an {@code + * IllegalStateException} only upon some subsequent operation on + * this phaser, if ever. * * @return the arrival phase number, or a negative value if terminated * @throws IllegalStateException if not terminated and the number @@ -571,68 +571,72 @@ public class Phaser { } /** - * Arrives at the barrier and awaits others. Equivalent in effect + * Arrives at this phaser and awaits others. Equivalent in effect * to {@code awaitAdvance(arrive())}. If you need to await with * interruption or timeout, you can arrange this with an analogous * construction using one of the other forms of the {@code * awaitAdvance} method. If instead you need to deregister upon - * arrival, use {@link #arriveAndDeregister}. It is a usage error - * for an unregistered party to invoke this method. However, it is - * possible that this error will result in an {code - * IllegalStateException} only when some other party - * arrives. + * arrival, use {@code awaitAdvance(arriveAndDeregister())}. + * + *

It is a usage error for an unregistered party to invoke this + * method. However, this error may result in an {@code + * IllegalStateException} only upon some subsequent operation on + * this phaser, if ever. * * @return the arrival phase number, or a negative number if terminated * @throws IllegalStateException if not terminated and the number * of unarrived parties would become negative */ public int arriveAndAwaitAdvance() { - return awaitAdvance(arrive()); + return awaitAdvance(doArrive(ONE_ARRIVAL)); } /** - * Awaits the phase of the barrier to advance from the given phase - * value, returning immediately if the current phase of the - * barrier is not equal to the given phase value or this barrier - * is terminated. + * Awaits the phase of this phaser to advance from the given phase + * value, returning immediately if the current phase is not equal + * to the given phase value or this phaser is terminated. * * @param phase an arrival phase number, or negative value if * terminated; this argument is normally the value returned by a - * previous call to {@code arrive} or its variants + * previous call to {@code arrive} or {@code arriveAndDeregister}. * @return the next arrival phase number, or a negative value * if terminated or argument is negative */ public int awaitAdvance(int phase) { + Phaser rt; + int p = (int)(state >>> PHASE_SHIFT); if (phase < 0) return phase; - long s = (parent == null) ? state : reconcileState(); - int p = (int)(s >>> PHASE_SHIFT); - return (p != phase) ? p : internalAwaitAdvance(phase, null); + if (p == phase && + (p = (int)((rt = root).state >>> PHASE_SHIFT)) == phase) + return rt.internalAwaitAdvance(phase, null); + return p; } /** - * Awaits the phase of the barrier to advance from the given phase + * Awaits the phase of this phaser to advance from the given phase * value, throwing {@code InterruptedException} if interrupted - * while waiting, or returning immediately if the current phase of - * the barrier is not equal to the given phase value or this - * barrier is terminated. + * while waiting, or returning immediately if the current phase is + * not equal to the given phase value or this phaser is + * terminated. * * @param phase an arrival phase number, or negative value if * terminated; this argument is normally the value returned by a - * previous call to {@code arrive} or its variants + * previous call to {@code arrive} or {@code arriveAndDeregister}. * @return the next arrival phase number, or a negative value * if terminated or argument is negative * @throws InterruptedException if thread interrupted while waiting */ public int awaitAdvanceInterruptibly(int phase) throws InterruptedException { + Phaser rt; + int p = (int)(state >>> PHASE_SHIFT); if (phase < 0) return phase; - long s = (parent == null) ? state : reconcileState(); - int p = (int)(s >>> PHASE_SHIFT); - if (p == phase) { + if (p == phase && + (p = (int)((rt = root).state >>> PHASE_SHIFT)) == phase) { QNode node = new QNode(this, phase, true, false, 0L); - p = internalAwaitAdvance(phase, node); + p = rt.internalAwaitAdvance(phase, node); if (node.wasInterrupted) throw new InterruptedException(); } @@ -640,16 +644,15 @@ public class Phaser { } /** - * Awaits the phase of the barrier to advance from the given phase + * Awaits the phase of this phaser to advance from the given phase * value or the given timeout to elapse, throwing {@code * InterruptedException} if interrupted while waiting, or - * returning immediately if the current phase of the barrier is - * not equal to the given phase value or this barrier is - * terminated. + * returning immediately if the current phase is not equal to the + * given phase value or this phaser is terminated. * * @param phase an arrival phase number, or negative value if * terminated; this argument is normally the value returned by a - * previous call to {@code arrive} or its variants + * previous call to {@code arrive} or {@code arriveAndDeregister}. * @param timeout how long to wait before giving up, in units of * {@code unit} * @param unit a {@code TimeUnit} determining how to interpret the @@ -662,14 +665,15 @@ public class Phaser { public int awaitAdvanceInterruptibly(int phase, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException { + long nanos = unit.toNanos(timeout); + Phaser rt; + int p = (int)(state >>> PHASE_SHIFT); if (phase < 0) return phase; - long s = (parent == null) ? state : reconcileState(); - int p = (int)(s >>> PHASE_SHIFT); - if (p == phase) { - long nanos = unit.toNanos(timeout); + if (p == phase && + (p = (int)((rt = root).state >>> PHASE_SHIFT)) == phase) { QNode node = new QNode(this, phase, true, true, nanos); - p = internalAwaitAdvance(phase, node); + p = rt.internalAwaitAdvance(phase, node); if (node.wasInterrupted) throw new InterruptedException(); else if (p == phase) @@ -679,7 +683,7 @@ public class Phaser { } /** - * Forces this barrier to enter termination state. Counts of + * Forces this phaser to enter termination state. Counts of * arrived and registered parties are unaffected. If this phaser * is a member of a tiered set of phasers, then all of the phasers * in the set are terminated. If this phaser is already @@ -704,7 +708,9 @@ public class Phaser { /** * Returns the current phase number. The maximum phase number is * {@code Integer.MAX_VALUE}, after which it restarts at - * zero. Upon termination, the phase number is negative. + * zero. Upon termination, the phase number is negative, + * in which case the prevailing phase prior to termination + * may be obtained via {@code getPhase() + Integer.MIN_VALUE}. * * @return the phase number, or a negative value if terminated */ @@ -713,7 +719,7 @@ public class Phaser { } /** - * Returns the number of parties registered at this barrier. + * Returns the number of parties registered at this phaser. * * @return the number of parties */ @@ -723,22 +729,27 @@ public class Phaser { /** * Returns the number of registered parties that have arrived at - * the current phase of this barrier. + * the current phase of this phaser. * * @return the number of arrived parties */ public int getArrivedParties() { - return arrivedOf(parent==null? state : reconcileState()); + long s = state; + int u = unarrivedOf(s); // only reconcile if possibly needed + return (u != 0 || parent == null) ? + partiesOf(s) - u : + arrivedOf(reconcileState()); } /** * Returns the number of registered parties that have not yet - * arrived at the current phase of this barrier. + * arrived at the current phase of this phaser. * * @return the number of unarrived parties */ public int getUnarrivedParties() { - return unarrivedOf(parent==null? state : reconcileState()); + int u = unarrivedOf(state); + return (u != 0 || parent == null) ? u : unarrivedOf(reconcileState()); } /** @@ -761,9 +772,9 @@ public class Phaser { } /** - * Returns {@code true} if this barrier has been terminated. + * Returns {@code true} if this phaser has been terminated. * - * @return {@code true} if this barrier has been terminated + * @return {@code true} if this phaser has been terminated */ public boolean isTerminated() { return root.state < 0L; @@ -772,23 +783,23 @@ public class Phaser { /** * Overridable method to perform an action upon impending phase * advance, and to control termination. This method is invoked - * upon arrival of the party tripping the barrier (when all other + * upon arrival of the party advancing this phaser (when all other * waiting parties are dormant). If this method returns {@code - * true}, then, rather than advance the phase number, this barrier + * true}, then, rather than advance the phase number, this phaser * will be set to a final termination state, and subsequent calls * to {@link #isTerminated} will return true. Any (unchecked) * Exception or Error thrown by an invocation of this method is - * propagated to the party attempting to trip the barrier, in + * propagated to the party attempting to advance this phaser, in * which case no advance occurs. * *

The arguments to this method provide the state of the phaser * prevailing for the current transition. The effects of invoking - * arrival, registration, and waiting methods on this Phaser from + * arrival, registration, and waiting methods on this phaser from * within {@code onAdvance} are unspecified and should not be * relied on. * - *

If this Phaser is a member of a tiered set of Phasers, then - * {@code onAdvance} is invoked only for its root Phaser on each + *

If this phaser is a member of a tiered set of phasers, then + * {@code onAdvance} is invoked only for its root phaser on each * advance. * *

To support the most common use cases, the default @@ -804,12 +815,13 @@ public class Phaser { * protected boolean onAdvance(int phase, int parties) { return false; } * }} * - * @param phase the phase number on entering the barrier + * @param phase the current phase number on entry to this method, + * before this phaser is advanced * @param registeredParties the current number of registered parties - * @return {@code true} if this barrier should terminate + * @return {@code true} if this phaser should terminate */ protected boolean onAdvance(int phase, int registeredParties) { - return registeredParties <= 0; + return registeredParties == 0; } /** @@ -819,7 +831,7 @@ public class Phaser { * followed by the number of registered parties, and {@code * "arrived = "} followed by the number of arrived parties. * - * @return a string identifying this barrier, as well as its state + * @return a string identifying this phaser, as well as its state */ public String toString() { return stateToString(reconcileState()); @@ -841,14 +853,18 @@ public class Phaser { * Removes and signals threads from queue for phase. */ private void releaseWaiters(int phase) { - AtomicReference head = queueFor(phase); - QNode q; - int p; + QNode q; // first element of queue + int p; // its phase + Thread t; // its thread + AtomicReference head = (phase & 1) == 0 ? evenQ : oddQ; while ((q = head.get()) != null && ((p = q.phase) == phase || (int)(root.state >>> PHASE_SHIFT) != p)) { - if (head.compareAndSet(q, q.next)) - q.signal(); + if (head.compareAndSet(q, q.next) && + (t = q.thread) != null) { + q.thread = null; + LockSupport.unpark(t); + } } } @@ -863,15 +879,14 @@ public class Phaser { * avoid it when threads regularly arrive: When a thread in * internalAwaitAdvance notices another arrival before blocking, * and there appear to be enough CPUs available, it spins - * SPINS_PER_ARRIVAL more times before blocking. Plus, even on - * uniprocessors, there is at least one intervening Thread.yield - * before blocking. The value trades off good-citizenship vs big - * unnecessary slowdowns. + * SPINS_PER_ARRIVAL more times before blocking. The value trades + * off good-citizenship vs big unnecessary slowdowns. */ static final int SPINS_PER_ARRIVAL = (NCPU < 2) ? 1 : 1 << 8; /** * Possibly blocks and waits for phase to advance unless aborted. + * Call only from root node. * * @param phase current phase * @param node if non-null, the wait node to track interrupt and timeout; @@ -879,49 +894,33 @@ public class Phaser { * @return current phase */ private int internalAwaitAdvance(int phase, QNode node) { - Phaser current = this; // to eventually wait at root if tiered - boolean queued = false; // true when node is enqueued - int lastUnarrived = -1; // to increase spins upon change + releaseWaiters(phase-1); // ensure old queue clean + boolean queued = false; // true when node is enqueued + int lastUnarrived = 0; // to increase spins upon change int spins = SPINS_PER_ARRIVAL; long s; int p; - while ((p = (int)((s = current.state) >>> PHASE_SHIFT)) == phase) { - Phaser par; - int unarrived = (int)s & UNARRIVED_MASK; - if (unarrived != lastUnarrived) { - if (lastUnarrived == -1) // ensure old queue clean - releaseWaiters(phase-1); - if ((lastUnarrived = unarrived) < NCPU) + while ((p = (int)((s = state) >>> PHASE_SHIFT)) == phase) { + if (node == null) { // spinning in noninterruptible mode + int unarrived = (int)s & UNARRIVED_MASK; + if (unarrived != lastUnarrived && + (lastUnarrived = unarrived) < NCPU) spins += SPINS_PER_ARRIVAL; - } - else if (unarrived == 0 && (par = current.parent) != null) { - current = par; // if all arrived, use parent - par = par.parent; - lastUnarrived = -1; - } - else if (spins > 0) { - if (--spins == (SPINS_PER_ARRIVAL >>> 1)) - Thread.yield(); // yield midway through spin - } - else if (node == null) // must be noninterruptible - node = new QNode(this, phase, false, false, 0L); - else if (node.isReleasable()) { - if ((p = (int)(root.state >>> PHASE_SHIFT)) != phase) - break; - else - return phase; // aborted - } - else if (!queued) { // push onto queue - AtomicReference head = queueFor(phase); - QNode q = head.get(); - if (q == null || q.phase == phase) { - node.next = q; - if ((p = (int)(root.state >>> PHASE_SHIFT)) != phase) - break; // recheck to avoid stale enqueue - else - queued = head.compareAndSet(q, node); + boolean interrupted = Thread.interrupted(); + if (interrupted || --spins < 0) { // need node to record intr + node = new QNode(this, phase, false, false, 0L); + node.wasInterrupted = interrupted; } } + else if (node.isReleasable()) // done or aborted + break; + else if (!queued) { // push onto queue + AtomicReference head = (phase & 1) == 0 ? evenQ : oddQ; + QNode q = node.next = head.get(); + if ((q == null || q.phase == phase) && + (int)(state >>> PHASE_SHIFT) == phase) // avoid stale enq + queued = head.compareAndSet(q, node); + } else { try { ForkJoinPool.managedBlock(node); @@ -930,9 +929,16 @@ public class Phaser { } } } + + if (node != null) { + if (node.thread != null) + node.thread = null; // avoid need for unpark() + if (node.wasInterrupted && !node.interruptible) + Thread.currentThread().interrupt(); + if ((p = (int)(state >>> PHASE_SHIFT)) == phase) + return p; // recheck abort + } releaseWaiters(phase); - if (node != null) - node.onRelease(); return p; } @@ -957,35 +963,35 @@ public class Phaser { this.interruptible = interruptible; this.nanos = nanos; this.timed = timed; - this.lastTime = timed? System.nanoTime() : 0L; + this.lastTime = timed ? System.nanoTime() : 0L; thread = Thread.currentThread(); } public boolean isReleasable() { - Thread t = thread; - if (t != null) { - if (phaser.getPhase() != phase) - t = null; - else { - if (Thread.interrupted()) - wasInterrupted = true; - if (interruptible && wasInterrupted) - t = null; - else if (timed) { - if (nanos > 0) { - long now = System.nanoTime(); - nanos -= now - lastTime; - lastTime = now; - } - if (nanos <= 0) - t = null; - } - } - if (t != null) - return false; + if (thread == null) + return true; + if (phaser.getPhase() != phase) { + thread = null; + return true; + } + if (Thread.interrupted()) + wasInterrupted = true; + if (wasInterrupted && interruptible) { thread = null; + return true; } - return true; + if (timed) { + if (nanos > 0L) { + long now = System.nanoTime(); + nanos -= now - lastTime; + lastTime = now; + } + if (nanos <= 0L) { + thread = null; + return true; + } + } + return false; } public boolean block() { @@ -997,22 +1003,6 @@ public class Phaser { LockSupport.parkNanos(this, nanos); return isReleasable(); } - - void signal() { - Thread t = thread; - if (t != null) { - thread = null; - LockSupport.unpark(t); - } - } - - void onRelease() { // actions upon return from internalAwaitAdvance - if (!interruptible && wasInterrupted) - Thread.currentThread().interrupt(); - if (thread != null) - thread = null; - } - } // Unsafe mechanics