How to use jsr166y

/**
 * Returns the first unmatched node of the given mode, or null if
 * none.  Used by methods isEmpty, hasWaitingConsumer.
 */
private Node firstOfMode(boolean isData) {
  for (Node p = head; p != null; p = succ(p)) {
    if (!p.isMatched())
      return (p.isData == isData) ? p : null;
  }
  return null;
}

/**
 * @throws NullPointerException if the task is null
 * @throws RejectedExecutionException if the task cannot be
 *         scheduled for execution
 */
public <T> ForkJoinTask<T> submit(Callable<T> task) {
  ForkJoinTask<T> job = new ForkJoinTask.AdaptedCallable<T>(task);
  doSubmit(job);
  return job;
}

public E pollFirst() {
  for (Node<E> p = first(); p != null; p = succ(p)) {
    E item = p.item;
    if (item != null && p.casItem(item, null)) {
      unlink(p);
      return item;
    }
  }
  return null;
}

/**
 * Polls and runs tasks until empty.
 */
private void pollAndExecAll() {
  for (ForkJoinTask<?> t; (t = poll()) != null;)
    t.doExec();
}

/**
 * Top-level runloop for workers, called by ForkJoinWorkerThread.run.
 */
final void runWorker(WorkQueue w) {
  w.growArray(false);         // initialize queue array in this thread
  do { w.runTask(scan(w)); } while (w.runState >= 0);
}

public E pollLast() {
  for (Node<E> p = last(); p != null; p = pred(p)) {
    E item = p.item;
    if (item != null && p.casItem(item, null)) {
      unlink(p);
      return item;
    }
  }
  return null;
}

/**
 * Removes and cancels all known tasks, ignoring any exceptions.
 */
final void cancelAll() {
  ForkJoinTask.cancelIgnoringExceptions(currentJoin);
  ForkJoinTask.cancelIgnoringExceptions(currentSteal);
  for (ForkJoinTask<?> t; (t = poll()) != null; )
    ForkJoinTask.cancelIgnoringExceptions(t);
}

/**
 * Returns the number of registered parties that have arrived at
 * the current phase of this phaser. If this phaser has terminated,
 * the returned value is meaningless and arbitrary.
 *
 * @return the number of arrived parties
 */
public int getArrivedParties() {
  return arrivedOf(reconcileState());
}

/**
 * @throws NullPointerException if the task is null
 * @throws RejectedExecutionException if the task cannot be
 *         scheduled for execution
 */
public <T> ForkJoinTask<T> submit(Runnable task, T result) {
  ForkJoinTask<T> job = new ForkJoinTask.AdaptedRunnable<T>(task, result);
  doSubmit(job);
  return job;
}

/**
 * Returns a new {@code ForkJoinTask} that performs the {@code call}
 * method of the given {@code Callable} as its action, and returns
 * its result upon {@link #join}, translating any checked exceptions
 * encountered into {@code RuntimeException}.
 *
 * @param callable the callable action
 * @return the task
 */
public static <T> ForkJoinTask<T> adapt(Callable<? extends T> callable) {
  return new AdaptedCallable<T>(callable);
}

/**
 * @throws NoSuchElementException {@inheritDoc}
 */
public E getLast() {
  return screenNullResult(peekLast());
}

/**
 * Inserts the specified element at the tail of this queue.
 * As the queue is unbounded, this method will never throw
 * {@link IllegalStateException} or return {@code false}.
 *
 * @return {@code true} (as specified by {@link Collection#add})
 * @throws NullPointerException if the specified element is null
 */
public boolean add(E e) {
  xfer(e, true, ASYNC, 0);
  return true;
}

/**
 * @throws NoSuchElementException {@inheritDoc}
 */
public E removeFirst() {
  return screenNullResult(pollFirst());
}

/**
 * Returns message string for bounds exceptions on registration.
 */
private String badRegister(long s) {
  return "Attempt to register more than " +
    MAX_PARTIES + " parties for " + stateToString(s);
}

/**
 * Joins this task, without returning its result or throwing its
 * exception. This method may be useful when processing
 * collections of tasks when some have been cancelled or otherwise
 * known to have aborted.
 */
public final void quietlyJoin() {
  doJoin();
}

/**
 * Returns a new {@code ForkJoinTask} that performs the {@code run}
 * method of the given {@code Runnable} as its action, and returns
 * the given result upon {@link #join}.
 *
 * @param runnable the runnable action
 * @param result the result upon completion
 * @return the task
 */
public static <T> ForkJoinTask<T> adapt(Runnable runnable, T result) {
  return new AdaptedRunnable<T>(runnable, result);
}

/**
 * Inserts the specified element at the tail of this deque.
 * As the deque is unbounded, this method will never return {@code false}.
 *
 * @return {@code true} (as specified by {@link Queue#offer})
 * @throws NullPointerException if the specified element is null
 */
public boolean offer(E e) {
  return offerLast(e);
}

/**
 * Returns a new {@code ForkJoinTask} that performs the {@code run}
 * method of the given {@code Runnable} as its action, and returns
 * a null result upon {@link #join}.
 *
 * @param runnable the runnable action
 * @return the task
 */
public static ForkJoinTask<?> adapt(Runnable runnable) {
  return new AdaptedRunnableAction(runnable);
}

/**
 * Removes all of the elements from this deque.
 */
public void clear() {
  while (pollFirst() != null)
    ;
}

/**
 * Returns {@code true} if this queue contains no elements.
 *
 * @return {@code true} if this queue contains no elements
 */
public boolean isEmpty() {
  for (Node p = head; p != null; p = succ(p)) {
    if (!p.isMatched())
      return !p.isData;
  }
  return true;
}