/*

/**

private volatile long state;

private static final int MAX_PARTIES = 0xffff;

private static final int MAX_PHASE = Integer.MAX_VALUE;

private static final int PARTIES_SHIFT = 16;

private static final int PHASE_SHIFT = 32;

private static final int UNARRIVED_MASK = 0xffff; // to mask ints

private static final long PARTIES_MASK = 0xffff0000L; // to mask longs

private static final long COUNTS_MASK = 0xffffffffL;

private static final long TERMINATION_BIT = 1L << 63;

// some special values

private static final int ONE_ARRIVAL = 1;

private static final int ONE_PARTY = 1 << PARTIES_SHIFT;

private static final int ONE_DEREGISTER = ONE_ARRIVAL|ONE_PARTY;

private static final int EMPTY = 1;

// The following unpacking methods are usually manually inlined

private static int unarrivedOf(long s) {

int counts = (int)s;

return (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);

}

private static int partiesOf(long s) {

return (int)s >>> PARTIES_SHIFT;

}

private static int phaseOf(long s) {

return (int)(s >>> PHASE_SHIFT);

}

private static int arrivedOf(long s) {

int counts = (int)s;

return (counts == EMPTY) ? 0 :

(counts >>> PARTIES_SHIFT) - (counts & UNARRIVED_MASK);

}

/**

private final Phaser parent;

/**

private final Phaser root;

/**

private final AtomicReference<QNode> evenQ;

private final AtomicReference<QNode> oddQ;

private AtomicReference<QNode> queueFor(int phase) {

return ((phase & 1) == 0) ? evenQ : oddQ;

}

/**

private String badArrive(long s) {

return "Attempted arrival of unregistered party for " +

stateToString(s);

}

/**

private String badRegister(long s) {

return "Attempt to register more than " +

MAX_PARTIES + " parties for " + stateToString(s);

}

/**

private int doArrive(int adjust) {

final Phaser root = this.root;

for (;;) {

long s = (root == this) ? state : reconcileState();

int phase = (int)(s >>> PHASE_SHIFT);

if (phase < 0)

return phase;

int counts = (int)s;

int unarrived = (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);

if (unarrived <= 0)

throw new IllegalStateException(badArrive(s));

if (UNSAFE.compareAndSwapLong(this, stateOffset, s, s-=adjust)) {

if (unarrived == 1) {

long n = s & PARTIES_MASK; // base of next state

int nextUnarrived = (int)n >>> PARTIES_SHIFT;

if (root == this) {

if (onAdvance(phase, nextUnarrived))

n |= TERMINATION_BIT;

else if (nextUnarrived == 0)

n |= EMPTY;

else

n |= nextUnarrived;

int nextPhase = (phase + 1) & MAX_PHASE;

n |= (long)nextPhase << PHASE_SHIFT;

UNSAFE.compareAndSwapLong(this, stateOffset, s, n);

releaseWaiters(phase);

}

else if (nextUnarrived == 0) { // propagate deregistration

phase = parent.doArrive(ONE_DEREGISTER);

UNSAFE.compareAndSwapLong(this, stateOffset,

s, s | EMPTY);

}

else

phase = parent.doArrive(ONE_ARRIVAL);

}

return phase;

}

}

}

/**

private int doRegister(int registrations) {

// adjustment to state

long adjust = ((long)registrations << PARTIES_SHIFT) | registrations;

final Phaser parent = this.parent;

int phase;

for (;;) {

long s = (parent == null) ? state : reconcileState();

int counts = (int)s;

int parties = counts >>> PARTIES_SHIFT;

int unarrived = counts & UNARRIVED_MASK;

if (registrations > MAX_PARTIES - parties)

throw new IllegalStateException(badRegister(s));

phase = (int)(s >>> PHASE_SHIFT);

if (phase < 0)

break;

if (counts != EMPTY) { // not 1st registration

if (parent == null || reconcileState() == s) {

if (unarrived == 0) // wait out advance

root.internalAwaitAdvance(phase, null);

else if (UNSAFE.compareAndSwapLong(this, stateOffset,

s, s + adjust))

break;

}

}

else if (parent == null) { // 1st root registration

long next = ((long)phase << PHASE_SHIFT) | adjust;

if (UNSAFE.compareAndSwapLong(this, stateOffset, s, next))

break;

}

else {

synchronized (this) { // 1st sub registration

if (state == s) { // recheck under lock

phase = parent.doRegister(1);

if (phase < 0)

break;

// finish registration whenever parent registration

// succeeded, even when racing with termination,

// since these are part of the same "transaction".

while (!UNSAFE.compareAndSwapLong

(this, stateOffset, s,

((long)phase << PHASE_SHIFT) | adjust)) {

s = state;

phase = (int)(root.state >>> PHASE_SHIFT);

// assert (int)s == EMPTY;

}

break;

}

}

}

}

return phase;

}

/**

private long reconcileState() {

final Phaser root = this.root;

long s = state;

if (root != this) {

int phase, p;

// CAS to root phase with current parties, tripping unarrived

while ((phase = (int)(root.state >>> PHASE_SHIFT)) !=

(int)(s >>> PHASE_SHIFT) &&

!UNSAFE.compareAndSwapLong

(this, stateOffset, s,

s = (((long)phase << PHASE_SHIFT) |

((phase < 0) ? (s & COUNTS_MASK) :

(((p = (int)s >>> PARTIES_SHIFT) == 0) ? EMPTY :

((s & PARTIES_MASK) | p))))))

s = state;

}

return s;

}

/**

public Phaser() {

this(null, 0);

}

/**

public Phaser(int parties) {

this(null, parties);

}

/**

public Phaser(Phaser parent) {

this(parent, 0);

}

/**

public Phaser(Phaser parent, int parties) {

if (parties >>> PARTIES_SHIFT != 0)

throw new IllegalArgumentException("Illegal number of parties");

int phase = 0;

this.parent = parent;

if (parent != null) {

final Phaser root = parent.root;

this.root = root;

this.evenQ = root.evenQ;

this.oddQ = root.oddQ;

if (parties != 0)

phase = parent.doRegister(1);

}

else {

this.root = this;

this.evenQ = new AtomicReference<QNode>();

this.oddQ = new AtomicReference<QNode>();

}

this.state = (parties == 0) ? (long)EMPTY :

((long)phase << PHASE_SHIFT) |

((long)parties << PARTIES_SHIFT) |

((long)parties);

}

/**

public int register() {

return doRegister(1);

}

/**

public int bulkRegister(int parties) {

if (parties < 0)

throw new IllegalArgumentException();

if (parties == 0)

return getPhase();

return doRegister(parties);

}

/**

public int arrive() {

return doArrive(ONE_ARRIVAL);

}

/**

public int arriveAndDeregister() {

return doArrive(ONE_DEREGISTER);

}

/**

public int arriveAndAwaitAdvance() {

// Specialization of doArrive+awaitAdvance eliminating some reads/paths

final Phaser root = this.root;

for (;;) {

long s = (root == this) ? state : reconcileState();

int phase = (int)(s >>> PHASE_SHIFT);

if (phase < 0)

return phase;

int counts = (int)s;

int unarrived = (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);

if (unarrived <= 0)

throw new IllegalStateException(badArrive(s));

if (UNSAFE.compareAndSwapLong(this, stateOffset, s,

s -= ONE_ARRIVAL)) {

if (unarrived > 1)

return root.internalAwaitAdvance(phase, null);

if (root != this)

return parent.arriveAndAwaitAdvance();

long n = s & PARTIES_MASK; // base of next state

int nextUnarrived = (int)n >>> PARTIES_SHIFT;

if (onAdvance(phase, nextUnarrived))

n |= TERMINATION_BIT;

else if (nextUnarrived == 0)

n |= EMPTY;

else

n |= nextUnarrived;

int nextPhase = (phase + 1) & MAX_PHASE;

n |= (long)nextPhase << PHASE_SHIFT;

if (!UNSAFE.compareAndSwapLong(this, stateOffset, s, n))

return (int)(state >>> PHASE_SHIFT); // terminated

releaseWaiters(phase);

return nextPhase;

}

}

}

/**

public int awaitAdvance(int phase) {

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)

return root.internalAwaitAdvance(phase, null);

return p;

}

/**

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;

}

/**

public int awaitAdvanceInterruptibly(int phase,

long timeout, TimeUnit unit)

throws InterruptedException, TimeoutException {

long nanos = unit.toNanos(timeout);

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, true, nanos);

p = root.internalAwaitAdvance(phase, node);

if (node.wasInterrupted)

throw new InterruptedException();

else if (p == phase)

throw new TimeoutException();

}

return p;

}

/**

public void forceTermination() {

// Only need to change root state

final Phaser root = this.root;

long s;

while ((s = root.state) >= 0) {

if (UNSAFE.compareAndSwapLong(root, stateOffset,

s, s | TERMINATION_BIT)) {

// signal all threads

releaseWaiters(0); // Waiters on evenQ

releaseWaiters(1); // Waiters on oddQ

return;

}

}

}

/**

public final int getPhase() {

return (int)(root.state >>> PHASE_SHIFT);

}

/**

public int getRegisteredParties() {

return partiesOf(state);

}

/**

public int getArrivedParties() {

return arrivedOf(reconcileState());

}

/**

public int getUnarrivedParties() {

return unarrivedOf(reconcileState());

}

/**

public Phaser getParent() {

return parent;

}

/**

public Phaser getRoot() {

return root;

}

/**

public boolean isTerminated() {

return root.state < 0L;

}

/**

protected boolean onAdvance(int phase, int registeredParties) {

return registeredParties == 0;

}

/**

public String toString() {

return stateToString(reconcileState());

}

/**

private String stateToString(long s) {

return super.toString() +

"[phase = " + phaseOf(s) +

" parties = " + partiesOf(s) +

" arrived = " + arrivedOf(s) + "]";

}

// Waiting mechanics

/**

private void releaseWaiters(int phase) {

QNode q; // first element of queue

Thread t; // its thread

AtomicReference<QNode> head = (phase & 1) == 0 ? evenQ : oddQ;

while ((q = head.get()) != null &&

q.phase != (int)(root.state >>> PHASE_SHIFT)) {

if (head.compareAndSet(q, q.next) &&

(t = q.thread) != null) {

q.thread = null;

LockSupport.unpark(t);

}

}

}

/**

private int abortWait(int phase) {

AtomicReference<QNode> head = (phase & 1) == 0 ? evenQ : oddQ;

for (;;) {

Thread t;

QNode q = head.get();