/**
     * Main pool control -- a long packed with:
     * AC: Number of active running workers minus target parallelism (16 bits)
     * TC: Number of total workers minus target parallelism (16bits)
     * ST: true if pool is terminating (1 bit)
     * EC: the wait count of top waiting thread (15 bits)
     * ID: ~poolIndex of top of Treiber stack of waiting threads (16 bits)
     *
     * When convenient, we can extract the upper 32 bits of counts and
     * the lower 32 bits of queue state, u = (int)(ctl >>> 32) and e =
     * (int)ctl.  The ec field is never accessed alone, but always
     * together with id and st. The offsets of counts by the target
     * parallelism and the positionings of fields makes it possible to
     * perform the most common checks via sign tests of fields: When
     * ac is negative, there are not enough active workers, when tc is
     * negative, there are not enough total workers, when id is
     * negative, there is at least one waiting worker, and when e is
     * negative, the pool is terminating.  To deal with these possibly
     * negative fields, we use casts in and out of "short" and/or
     * signed shifts to maintain signedness.
     */
    volatile long ctl;

    // bit positions/shifts for fields
    private static final int  AC_SHIFT   = 48;
    private static final int  TC_SHIFT   = 32;
    private static final int  ST_SHIFT   = 31;
    private static final int  EC_SHIFT   = 16;

    // bounds
    private static final int  MAX_ID     = 0x7fff;  // max poolIndex
    private static final int  SMASK      = 0xffff;  // mask short bits
    private static final int  SHORT_SIGN = 1 << 15;
    private static final int  INT_SIGN   = 1 << 31;

    // masks
    private static final long STOP_BIT   = 0x0001L << ST_SHIFT;
    private static final long AC_MASK    = ((long)SMASK) << AC_SHIFT;
    private static final long TC_MASK    = ((long)SMASK) << TC_SHIFT;

    // units for incrementing and decrementing
    private static final long TC_UNIT    = 1L << TC_SHIFT;
    private static final long AC_UNIT    = 1L << AC_SHIFT;

    // masks and units for dealing with u = (int)(ctl >>> 32)
    private static final int  UAC_SHIFT  = AC_SHIFT - 32;
    private static final int  UTC_SHIFT  = TC_SHIFT - 32;
    private static final int  UAC_MASK   = SMASK << UAC_SHIFT;
    private static final int  UTC_MASK   = SMASK << UTC_SHIFT;
    private static final int  UAC_UNIT   = 1 << UAC_SHIFT;
    private static final int  UTC_UNIT   = 1 << UTC_SHIFT;

    // masks and units for dealing with e = (int)ctl
    private static final int  E_MASK     = 0x7fffffff; // no STOP_BIT
    private static final int  EC_UNIT    = 1 << EC_SHIFT;

/**
 * SeqLock and index masking for updates to workers array.  Locked
 * when SG_UNIT is set. Unlocking clears bit by adding
 * SG_UNIT. Staleness of read-only operations can be checked by
 * comparing scanGuard to value before the reads. The low 16 bits
 * (i.e, anding with SMASK) hold (the smallest power of two
 * covering all worker indices, minus one, and is used to avoid
 * dealing with large numbers of null slots when the workers array
 * is overallocated.
 */
volatile int scanGuard;

/**
 * Index (mod submission queue length) of next element to take
 * from submission queue. Usage is identical to that for
 * per-worker queues -- see ForkJoinWorkerThread internal
 * documentation.
 */
volatile int queueBase;

/**
 * Index (mod submission queue length) of next element to add
 * in submission queue. Usage is identical to that for
 * per-worker queues -- see ForkJoinWorkerThread internal
 * documentation.
 */
int queueTop;

/**
 * True if use local fifo, not default lifo, for local polling
 * Read by, and replicated by ForkJoinWorkerThreads
 */
final boolean locallyFifo;

/**
    * Capacity of work-stealing queue array upon initialization.
    * Must be a power of two. Initial size must be at least 4, but is
    * padded to minimize cache effects.
    */
   private static final int INITIAL_QUEUE_CAPACITY = 1 << 13;

   /**
    * Maximum size for queue array. Must be a power of two
    * less than or equal to 1 << (31 - width of array entry) to
    * ensure lack of index wraparound, but is capped at a lower
    * value to help users trap runaway computations.
    */
   private static final int MAXIMUM_QUEUE_CAPACITY = 1 << 24; // 16M

   /**
    * The work-stealing queue array. Size must be a power of two.
    * Initialized when started (as oposed to when constructed), to
    * improve memory locality.
    */
   ForkJoinTask<?>[] queue;

   /**
    * The pool this thread works in. Accessed directly by ForkJoinTask.
    */
   final ForkJoinPool pool;

   /**
    * Index (mod queue.length) of next queue slot to push to or pop
    * from. It is written only by owner thread, and accessed by other
    * threads only after reading (volatile) queueBase.  Both queueTop
    * and queueBase are allowed to wrap around on overflow, but
    * (queueTop - queueBase) still estimates size.
    */
   int queueTop;

   /**
    * Index (mod queue.length) of least valid queue slot, which is
    * always the next position to steal from if nonempty.
    */
   volatile int queueBase;

/**
 * Index of this worker in pool array. Set once by pool before
 * running, and accessed directly by pool to locate this worker in
 * its workers array.
 */
final int poolIndex;

/**
 * The index of most recent stealer, used as a hint to avoid
 * traversal in method helpJoinTask. This is only a hint because a
 * worker might have had multiple steals and this only holds one
 * of them (usually the most current). Declared non-volatile,
 * relying on other prevailing sync to keep reasonably current.
 */
int stealHint;

/**
  * Encoded record for pool task waits. Usages are always
  * surrounded by volatile reads/writes
  */
 int nextWait;

/**
 * True if use local fifo, not default lifo, for local polling.
 * Shadows value from ForkJoinPool.
 */
final boolean locallyFifo;

/**
 * The task most recently stolen from another worker (or
 * submission queue).  All uses are surrounded by enough volatile
 * reads/writes to maintain as non-volatile.
 */
ForkJoinTask<?> currentSteal;

/**
  * The task currently being joined, set only when actively trying
  * to help other stealers in helpJoinTask. All uses are surrounded
  * by enough volatile reads/writes to maintain as non-volatile.
  */
 ForkJoinTask<?> currentJoin;

/*
 * The status field holds run control status bits packed into a
 * single int to minimize footprint and to ensure atomicity (via
 * CAS).  Status is initially zero, and takes on nonnegative
 * values until completed, upon which status holds value
 * NORMAL, CANCELLED, or EXCEPTIONAL. Tasks undergoing blocking
 * waits by other threads have the SIGNAL bit set.  Completion of
 * a stolen task with SIGNAL set awakens any waiters via
 * notifyAll. Even though suboptimal for some purposes, we use
 * basic builtin wait/notify to take advantage of "monitor
 * inflation" in JVMs that we would otherwise need to emulate to
 * avoid adding further per-task bookkeeping overhead.  We want
 * these monitors to be "fat", i.e., not use biasing or thin-lock
 * techniques, so use some odd coding idioms that tend to avoid
 * them.
 */

/** The run status of this task */
volatile int status; // accessed directly by pool and workers
private static final int NORMAL      = -1;
private static final int CANCELLED   = -2;
private static final int EXCEPTIONAL = -3;
private static final int SIGNAL      =  1;

.....

/**
 * Creates a {@code ForkJoinPool} with the given parameters.
 *
 * @param parallelism the parallelism level. For default value,
 * use {@link java.lang.Runtime#availableProcessors}.
 * @param factory the factory for creating new threads. For default value,
 * use {@link #defaultForkJoinWorkerThreadFactory}.
 * @param handler the handler for internal worker threads that
 * terminate due to unrecoverable errors encountered while executing
 * tasks. For default value, use {@code null}.
 * @param asyncMode if true,
 * establishes local first-in-first-out scheduling mode for forked
 * tasks that are never joined. This mode may be more appropriate
 * than default locally stack-based mode in applications in which
 * worker threads only process event-style asynchronous tasks.
 * For default value, use {@code false}.
 * @throws IllegalArgumentException if parallelism less than or
 *         equal to zero, or greater than implementation limit
 * @throws NullPointerException if the factory is null
 * @throws SecurityException if a security manager exists and
 *         the caller is not permitted to modify threads
 *         because it does not hold {@link
 *         java.lang.RuntimePermission}{@code ("modifyThread")}
 */
public ForkJoinPool(int parallelism,
                    ForkJoinWorkerThreadFactory factory,
                    Thread.UncaughtExceptionHandler handler,
                    boolean asyncMode) {
    checkPermission();
    if (factory == null)
        throw new NullPointerException();
    if (parallelism <= 0 || parallelism > MAX_ID)
        throw new IllegalArgumentException();
    // 1
    this.parallelism = parallelism;
    // 2
    this.factory = factory;
    // 3
    this.ueh = handler;
    // 4
    this.locallyFifo = asyncMode;
    // 5
    long np = (long)(-parallelism); // offset ctl counts
    this.ctl = ((np << AC_SHIFT) & AC_MASK) | ((np << TC_SHIFT) & TC_MASK);
    // 6
    this.submissionQueue = new ForkJoinTask<?>[INITIAL_QUEUE_CAPACITY];
    // initialize workers array with room for 2*parallelism if possible
    // 7
    int n = parallelism << 1;
    if (n >= MAX_ID)
        n = MAX_ID;
    else { // See Hackers Delight, sec 3.2, where n < (1 << 16)
        n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8;
    }
    // 8
    workers = new ForkJoinWorkerThread[n + 1];
    this.submissionLock = new ReentrantLock();
    this.termination = submissionLock.newCondition();
    // 9
    StringBuilder sb = new StringBuilder("ForkJoinPool-");
    sb.append(poolNumberGenerator.incrementAndGet());
    sb.append("-worker-");
    this.workerNamePrefix = sb.toString();
}

/**
 * Default ForkJoinWorkerThreadFactory implementation; creates a
 * new ForkJoinWorkerThread.
 */
static class DefaultForkJoinWorkerThreadFactory
    implements ForkJoinWorkerThreadFactory {
    public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
        return new ForkJoinWorkerThread(pool);
    }
}

/**
 * Factory for creating new {@link ForkJoinWorkerThread}s.
 * A {@code ForkJoinWorkerThreadFactory} must be defined and used
 * for {@code ForkJoinWorkerThread} subclasses that extend base
 * functionality or initialize threads with different contexts.
 */
public static interface ForkJoinWorkerThreadFactory {
    /**
     * Returns a new worker thread operating in the given pool.
     *
     * @param pool the pool this thread works in
     * @throws NullPointerException if the pool is null
     */
    public ForkJoinWorkerThread newThread(ForkJoinPool pool);
}

/**
     * Submits a ForkJoinTask for execution.
     *
     * @param task the task to submit
     * @return the task
     * @throws NullPointerException if the task is null
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     */
    public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task) {
        if (task == null)
            throw new NullPointerException();
        forkOrSubmit(task);
        return task;
    }

    /**
     * @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) {
        if (task == null)
            throw new NullPointerException();
        ForkJoinTask<T> job = ForkJoinTask.adapt(task);
        forkOrSubmit(job);
        return job;
    }

    /**
     * @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) {
        if (task == null)
            throw new NullPointerException();
        ForkJoinTask<T> job = ForkJoinTask.adapt(task, result);
        forkOrSubmit(job);
        return job;
    }

    /**
     * @throws NullPointerException if the task is null
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     */
    public ForkJoinTask<?> submit(Runnable task) {
        if (task == null)
            throw new NullPointerException();
        ForkJoinTask<?> job;
        if (task instanceof ForkJoinTask<?>) // avoid re-wrap
            job = (ForkJoinTask<?>) task;
        else
            job = ForkJoinTask.adapt(task, null);
        forkOrSubmit(job);
        return job;
    }

/**
    * 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 AdaptedRunnable<Void>(runnable, null);
   }

   /**
    * 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);
   }

   /**
    * 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);
   }

/**
     * Adaptor for Callables
     */
    static final class AdaptedCallable<T> extends ForkJoinTask<T>
        implements RunnableFuture<T> {
        final Callable<? extends T> callable;
        T result;
        AdaptedCallable(Callable<? extends T> callable) {
            if (callable == null) throw new NullPointerException();
            this.callable = callable;
        }
        public T getRawResult() { return result; }
        public void setRawResult(T v) { result = v; }
        public boolean exec() {
            try {
                result = callable.call();
                return true;
            } catch (Error err) {
                throw err;
            } catch (RuntimeException rex) {
                throw rex;
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
        public void run() { invoke(); }
        private static final long serialVersionUID = 2838392045355241008L;
    }

/**
 * Adaptor for Runnables. This implements RunnableFuture
 * to be compliant with AbstractExecutorService constraints
 * when used in ForkJoinPool.
 */
static final class AdaptedRunnable<T> extends ForkJoinTask<T>
    implements RunnableFuture<T> {
    final Runnable runnable;
    final T resultOnCompletion;
    T result;
    AdaptedRunnable(Runnable runnable, T result) {
        if (runnable == null) throw new NullPointerException();
        this.runnable = runnable;
        this.resultOnCompletion = result;
    }
    public T getRawResult() { return result; }
    public void setRawResult(T v) { result = v; }
    public boolean exec() {
        runnable.run();
        result = resultOnCompletion;
        return true;
    }
    public void run() { invoke(); }
    private static final long serialVersionUID = 5232453952276885070L;
}

/**
  * Unless terminating, forks task if within an ongoing FJ
  * computation in the current pool, else submits as external task.
  */
 private <T> void forkOrSubmit(ForkJoinTask<T> task) {
     ForkJoinWorkerThread w;
     Thread t = Thread.currentThread();
     if (shutdown)
         throw new RejectedExecutionException();
     if ((t instanceof ForkJoinWorkerThread) &&
         (w = (ForkJoinWorkerThread)t).pool == this)
         w.pushTask(task);
     else
         addSubmission(task);
 }

/**
  * Enqueues the given task in the submissionQueue.  Same idea as
  * ForkJoinWorkerThread.pushTask except for use of submissionLock.
  *
  * @param t the task
  */
 private void addSubmission(ForkJoinTask<?> t) {
     final ReentrantLock lock = this.submissionLock;
     lock.lock();
     try {
         ForkJoinTask<?>[] q; int s, m;
         if ((q = submissionQueue) != null) {    // ignore if queue removed
             // 1
             long u = (((s = queueTop) & (m = q.length-1)) << ASHIFT)+ABASE;
             // 2
             UNSAFE.putOrderedObject(q, u, t);
             queueTop = s + 1;
             if (s - queueBase == m)
                 // 3
                 growSubmissionQueue();
         }
     } finally {
         lock.unlock();
     }
     // 4
     signalWork();
 }

/**
    * Wakes up or creates a worker.
    */
   final void signalWork() {
       /*
        * The while condition is true if: (there is are too few total
        * workers OR there is at least one waiter) AND (there are too
        * few active workers OR the pool is terminating).  The value
        * of e distinguishes the remaining cases: zero (no waiters)
        * for create, negative if terminating (in which case do
        * nothing), else release a waiter. The secondary checks for
        * release (non-null array etc) can fail if the pool begins
        * terminating after the test, and don't impose any added cost
        * because JVMs must perform null and bounds checks anyway.
        */
       long c; int e, u;
       // 0
       while ((((e = (int)(c = ctl)) | (u = (int)(c >>> 32))) &
               (INT_SIGN|SHORT_SIGN)) == (INT_SIGN|SHORT_SIGN) && e >= 0) {
           if (e > 0) {                         // release a waiting worker
               // 1
               int i; ForkJoinWorkerThread w; ForkJoinWorkerThread[] ws;
               // 2
               if ((ws = workers) == null ||
                   (i = ~e & SMASK) >= ws.length ||
                   (w = ws[i]) == null)
                   break;
               // 3
               long nc = (((long)(w.nextWait & E_MASK)) |
                          ((long)(u + UAC_UNIT) << 32));
               if (w.eventCount == e &&
                   UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
                   // 4
                   w.eventCount = (e + EC_UNIT) & E_MASK;
                   if (w.parked)
                       // 5
                       UNSAFE.unpark(w);
                   break;
               }
           }//6
           else if (UNSAFE.compareAndSwapLong
                    (this, ctlOffset, c,
                     (long)(((u + UTC_UNIT) & UTC_MASK) |
                            ((u + UAC_UNIT) & UAC_MASK)) << 32)) {
               // 8
               addWorker();
               break;
           }
       }
   }

/**
  * Counter for worker Thread names (unrelated to their poolIndex)
  */
 private volatile int nextWorkerNumber; 
/**
  * Callback from ForkJoinWorkerThread constructor to assign a
  * public name
  */
 final String nextWorkerName() {
     for (int n;;) {
         if (UNSAFE.compareAndSwapInt(this, nextWorkerNumberOffset,
                                      n = nextWorkerNumber, ++n))
             return workerNamePrefix + n;
     }
 }

/**
     * Callback from ForkJoinWorkerThread constructor to
     * determine its poolIndex and record in workers array.
     *
     * @param w the worker
     * @return the worker's pool index
     */
    final int registerWorker(ForkJoinWorkerThread w) {
        /*
         * In the typical case, a new worker acquires the lock, uses
         * next available index and returns quickly.  Since we should
         * not block callers (ultimately from signalWork or
         * tryPreBlock) waiting for the lock needed to do this, we
         * instead help release other workers while waiting for the
         * lock.
         */
        for (int g;;) {
            ForkJoinWorkerThread[] ws;
            // 1
            if (((g = scanGuard) & SG_UNIT) == 0 &&
                UNSAFE.compareAndSwapInt(this, scanGuardOffset,
                                         g, g | SG_UNIT)) {
                int k = nextWorkerIndex;
                try {
                    if ((ws = workers) != null) { // ignore on shutdown
                        int n = ws.length;
                        if (k < 0 || k >= n || ws[k] != null) {
                            for (k = 0; k < n && ws[k] != null; ++k)
                                ;
                            if (k == n)
                                ws = workers = Arrays.copyOf(ws, n << 1);
                        }
                        ws[k] = w;
                        nextWorkerIndex = k + 1;
                        int m = g & SMASK;
                        g = (k > m) ? ((m << 1) + 1) & SMASK : g + (SG_UNIT<<1);
                    }
                } finally {
                    scanGuard = g;
                }
                return k;
            }
            else if ((ws = workers) != null) { // help release others
                for (ForkJoinWorkerThread u : ws) {
                    if (u != null && u.queueBase != u.queueTop) {
                        if (tryReleaseWaiter())
                            break;
                    }
                }
            }
        }
    }

/**
    * Initializes internal state after construction but before
    * processing any tasks. If you override this method, you must
    * invoke {@code super.onStart()} at the beginning of the method.
    * Initialization requires care: Most fields must have legal
    * default values, to ensure that attempted accesses from other
    * threads work correctly even before this thread starts
    * processing tasks.
    */
   protected void onStart() {
       // 1
       queue = new ForkJoinTask<?>[INITIAL_QUEUE_CAPACITY];
       // 2
       int r = pool.workerSeedGenerator.nextInt();
       // 3
       seed = (r == 0) ? 1 : r; //  must be nonzero
   }

/**
  * Implements execution conventions for RecursiveActions.
  */
 protected final boolean exec() {
     compute();
     return true;
 }

/**
 * The main computation performed by this task.
 */
protected abstract void compute();

/**
  * Implements execution conventions for RecursiveTask.
  */
 protected final boolean exec() {
     result = compute();
     return true;
 }

/**
 * The main computation performed by this task.
 */
protected abstract V compute();

volatile int status; // accessed directly by pool and workers
private static final int NORMAL      = -1;
/**
 * Marks completion and wakes up threads waiting to join this task,
 * also clearing signal request bits.
 *
 * @param completion one of NORMAL, CANCELLED, EXCEPTIONAL
 * @return completion status on exit
 */
private int setCompletion(int completion) {
    for (int s;;) {
        if ((s = status) < 0)
            return s;
        // 1
        if (UNSAFE.compareAndSwapInt(this, statusOffset, s, completion)) {
            if (s != 0)
                // 2
                synchronized (this) { notifyAll(); }
            return completion;
        }
    }
}

/**
     * Table of exceptions thrown by tasks, to enable reporting by
     * callers. Because exceptions are rare, we don't directly keep
     * them with task objects, but instead use a weak ref table.  Note
     * that cancellation exceptions don't appear in the table, but are
     * instead recorded as status values.
     *
     * Note: These statics are initialized below in static block.
     */
    private static final ExceptionNode[] exceptionTable;
    private static final ReentrantLock exceptionTableLock;
    private static final ReferenceQueue<Object> exceptionTableRefQueue;

    /**
     * Fixed capacity for exceptionTable.
     */
    private static final int EXCEPTION_MAP_CAPACITY = 32;

    /**
     * Key-value nodes for exception table.  The chained hash table
     * uses identity comparisons, full locking, and weak references
     * for keys. The table has a fixed capacity because it only
     * maintains task exceptions long enough for joiners to access
     * them, so should never become very large for sustained
     * periods. However, since we do not know when the last joiner
     * completes, we must use weak references and expunge them. We do
     * so on each operation (hence full locking). Also, some thread in
     * any ForkJoinPool will call helpExpungeStaleExceptions when its
     * pool becomes isQuiescent.
     */
    static final class ExceptionNode extends WeakReference<ForkJoinTask<?>>{
        final Throwable ex;
        ExceptionNode next;
        final long thrower;  // use id not ref to avoid weak cycles
        ExceptionNode(ForkJoinTask<?> task, Throwable ex, ExceptionNode next) {
            super(task, exceptionTableRefQueue);
            this.ex = ex;
            this.next = next;
            this.thrower = Thread.currentThread().getId();
        }
    }

// Unsafe mechanics
    private static final sun.misc.Unsafe UNSAFE;
    private static final long statusOffset;
    static {
        exceptionTableLock = new ReentrantLock();
        exceptionTableRefQueue = new ReferenceQueue<Object>();
        exceptionTable = new ExceptionNode[EXCEPTION_MAP_CAPACITY];
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            statusOffset = UNSAFE.objectFieldOffset
                (ForkJoinTask.class.getDeclaredField("status"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }

/**
     * Tries to enqueue worker w in wait queue and await change in
     * worker's eventCount.  If the pool is quiescent and there is
     * more than one worker, possibly terminates worker upon exit.
     * Otherwise, before blocking, rescans queues to avoid missed
     * signals.  Upon finding work, releases at least one worker
     * (which may be the current worker). Rescans restart upon
     * detected staleness or failure to release due to
     * contention. Note the unusual conventions about Thread.interrupt
     * here and elsewhere: Because interrupts are used solely to alert
     * threads to check termination, which is checked here anyway, we
     * clear status (using Thread.interrupted) before any call to
     * park, so that park does not immediately return due to status
     * being set via some other unrelated call to interrupt in user
     * code.
     *
     * @param w the calling worker
     * @param c the ctl value on entry
     * @return true if waited or another thread was released upon enq
     */
    private boolean tryAwaitWork(ForkJoinWorkerThread w, long c) {
        int v = w.eventCount;
        // 1
        w.nextWait = (int)c;                      // w's successor record
        // 2
        long nc = (long)(v & E_MASK) | ((c - AC_UNIT) & (AC_MASK|TC_MASK));
        if (ctl != c || !UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
            long d = ctl; // return true if lost to a deq, to force scan
            // 3
            return (int)d != (int)c && ((d - c) & AC_MASK) >= 0L;
        }
        for (int sc = w.stealCount; sc != 0;) {   // accumulate stealCount
            // 4
            long s = stealCount;
            if (UNSAFE.compareAndSwapLong(this, stealCountOffset, s, s + sc))
                sc = w.stealCount = 0;
            else if (w.eventCount != v)
                // 5
                return true;                      // update next time
        }
        // 6
        if ((!shutdown || !tryTerminate(false)) &&
            (int)c != 0 && parallelism + (int)(nc >> AC_SHIFT) == 0 &&
            blockedCount == 0 && quiescerCount == 0)
            // 7
            idleAwaitWork(w, nc, c, v);           // quiescent
        for (boolean rescanned = false;;) {
            if (w.eventCount != v)
                // 8
                return true;
            if (!rescanned) {
                int g = scanGuard, m = g & SMASK;
                ForkJoinWorkerThread[] ws = workers;
                if (ws != null && m < ws.length) {
                    rescanned = true;
                    // 9
                    for (int i = 0; i <= m; ++i) {
                        ForkJoinWorkerThread u = ws[i];
                        if (u != null) {
                            if (u.queueBase != u.queueTop &&
                                !tryReleaseWaiter())
                                // 10
                                rescanned = false; // contended
                            if (w.eventCount != v)
                                return true;
                        }
                    }
                }
                // 11
                if (scanGuard != g ||              // stale
                    (queueBase != queueTop && !tryReleaseWaiter()))
                    rescanned = false;
                if (!rescanned)
                    // 12
                    Thread.yield();                // reduce contention
                else
                    // 13
                    Thread.interrupted();          // clear before park
            }
            else {
                // 14
                w.parked = true;                   // must recheck
                if (w.eventCount != v) {
                    w.parked = false;
                    return true;
                }
                LockSupport.park(this);
                rescanned = w.parked = false;
            }
        }
    }

/**
  * Performs cleanup associated with termination of this worker
  * thread.  If you override this method, you must invoke
  * {@code super.onTermination} at the end of the overridden method.
  *
  * @param exception the exception causing this thread to abort due
  * to an unrecoverable error, or {@code null} if completed normally
  */
 protected void onTermination(Throwable exception) {
     try {
         terminate = true;
         cancelTasks();
         pool.deregisterWorker(this, exception);
     } catch (Throwable ex) {        // Shouldn't ever happen
         if (exception == null)      // but if so, at least rethrown
             exception = ex;
     } finally {
         if (exception != null)
             UNSAFE.throwException(exception);
     }
 }

/**
  * Removes and cancels all tasks in queue.  Can be called from any
  * thread.
  */
 final void cancelTasks() {
     ForkJoinTask<?> cj = currentJoin; // try to cancel ongoing tasks
     if (cj != null && cj.status >= 0)
         // 1
         cj.cancelIgnoringExceptions();
     ForkJoinTask<?> cs = currentSteal;
     if (cs != null && cs.status >= 0)
         // 2
         cs.cancelIgnoringExceptions();
     while (queueBase != queueTop) {
         // 3
         ForkJoinTask<?> t = deqTask();
         if (t != null)
             t.cancelIgnoringExceptions();
     }
 }