How to use

java.util.concurrent.Phaser$QNode

constructor

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

boolean interrupted = Thread.interrupted();
if (interrupted || --spins < 0) { // need node to record intr
  node = new QNode(this, phase, false, false, 0L);
  node.wasInterrupted = interrupted;

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

  return phase;
if (p == phase) {
  QNode node = new QNode(this, phase, true, true, nanos);
  p = root.internalAwaitAdvance(phase, node);
  if (node.wasInterrupted)

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}

/**
 * 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 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 {@code arriveAndDeregister}.
 * @return the next arrival phase number, or the argument if it is
 * negative, or the (negative) {@linkplain #getPhase() current phase}
 * if terminated
 * @throws InterruptedException if thread interrupted while waiting
 */
public int awaitAdvanceInterruptibly(int phase)
  throws InterruptedException {
  final Phaser root = this.root;
  long s = (root == this) ? state : reconcileState();
  int p = (int)(s >>> PHASE_SHIFT);
  if (phase < 0)
    return phase;
  if (p == phase) {
    QNode node = new QNode(this, phase, true, false, 0L);
    p = root.internalAwaitAdvance(phase, node);
    if (node.wasInterrupted)
      throw new InterruptedException();
  }
  return p;
}