As is the case with other ExecutorServices, there are three - * main task execution methods summarized in the follwoing + * main task execution methods summarized in the following * table. These are designed to be used by clients not already engaged * in fork/join computations in the current pool. The main forms of * these methods accept instances of {@code ForkJoinTask}, but @@ -69,7 +74,7 @@ import java.util.concurrent.CountDownLat *
This implementation rejects submitted tasks (that is, by throwing
* {@link RejectedExecutionException}) only when the pool is shut down
- * or internal resources have been exhuasted.
+ * or internal resources have been exhausted.
*
* @since 1.7
* @author Doug Lea
@@ -138,43 +143,43 @@ public class ForkJoinPool extends Abstra
* cache pollution effects.)
*
* Beyond work-stealing support and essential bookkeeping, the
- * main responsibility of this framework is to arrange tactics for
- * when one worker is waiting to join a task stolen (or always
- * held by) another. Becauae we are multiplexing many tasks on to
- * a pool of workers, we can't just let them block (as in
- * Thread.join). We also cannot just reassign the joiner's
- * run-time stack with another and replace it later, which would
- * be a form of "continuation", that even if possible is not
- * necessarily a good idea. Given that the creation costs of most
- * threads on most systems mainly surrounds setting up runtime
- * stacks, thread creation and switching is usually not much more
- * expensive than stack creation and switching, and is more
- * flexible). Instead we combine two tactics:
+ * main responsibility of this framework is to take actions when
+ * one worker is waiting to join a task stolen (or always held by)
+ * another. Because we are multiplexing many tasks on to a pool
+ * of workers, we can't just let them block (as in Thread.join).
+ * We also cannot just reassign the joiner's run-time stack with
+ * another and replace it later, which would be a form of
+ * "continuation", that even if possible is not necessarily a good
+ * idea. Given that the creation costs of most threads on most
+ * systems mainly surrounds setting up runtime stacks, thread
+ * creation and switching is usually not much more expensive than
+ * stack creation and switching, and is more flexible). Instead we
+ * combine two tactics:
*
- * 1. Arranging for the joiner to execute some task that it
+ * Helping: Arranging for the joiner to execute some task that it
* would be running if the steal had not occurred. Method
* ForkJoinWorkerThread.helpJoinTask tracks joining->stealing
* links to try to find such a task.
*
- * 2. Unless there are already enough live threads, creating or
- * or re-activating a spare thread to compensate for the
- * (blocked) joiner until it unblocks. Spares then suspend
- * at their next opportunity or eventually die if unused for
- * too long. See below and the internal documentation
- * for tryAwaitJoin for more details about compensation
- * rules.
- *
- * Because the determining existence of conservatively safe
- * helping targets, the availability of already-created spares,
- * and the apparent need to create new spares are all racy and
- * require heuristic guidance, joins (in
- * ForkJoinWorkerThread.joinTask) interleave these options until
- * successful. Creating a new spare always succeeds, but also
- * increases application footprint, so we try to avoid it, within
- * reason.
+ * Compensating: Unless there are already enough live threads,
+ * method helpMaintainParallelism() may create or
+ * re-activate a spare thread to compensate for blocked
+ * joiners until they unblock.
+ *
+ * It is impossible to keep exactly the target (parallelism)
+ * number of threads running at any given time. Determining
+ * existence of conservatively safe helping targets, the
+ * availability of already-created spares, and the apparent need
+ * to create new spares are all racy and require heuristic
+ * guidance, so we rely on multiple retries of each. Compensation
+ * occurs in slow-motion. It is triggered only upon timeouts of
+ * Object.wait used for joins. This reduces poor decisions that
+ * would otherwise be made when threads are waiting for others
+ * that are stalled because of unrelated activities such as
+ * garbage collection.
*
- * The ManagedBlocker extension API can't use option (1) so uses a
- * special version of (2) in method awaitBlocker.
+ * The ManagedBlocker extension API can't use helping so relies
+ * only on compensation in method awaitBlocker.
*
* The main throughput advantages of work-stealing stem from
* decentralized control -- workers mostly steal tasks from each
@@ -207,17 +212,30 @@ public class ForkJoinPool extends Abstra
* blocked workers. However, all other support code is set up to
* work with other policies.
*
+ * To ensure that we do not hold on to worker references that
+ * would prevent GC, ALL accesses to workers are via indices into
+ * the workers array (which is one source of some of the unusual
+ * code constructions here). In essence, the workers array serves
+ * as a WeakReference mechanism. Thus for example the event queue
+ * stores worker indices, not worker references. Access to the
+ * workers in associated methods (for example releaseEventWaiters)
+ * must both index-check and null-check the IDs. All such accesses
+ * ignore bad IDs by returning out early from what they are doing,
+ * since this can only be associated with shutdown, in which case
+ * it is OK to give up. On termination, we just clobber these
+ * data structures without trying to use them.
+ *
* 2. Bookkeeping for dynamically adding and removing workers. We
* aim to approximately maintain the given level of parallelism.
* When some workers are known to be blocked (on joins or via
* ManagedBlocker), we may create or resume others to take their
* place until they unblock (see below). Implementing this
* requires counts of the number of "running" threads (i.e., those
- * that are neither blocked nor artifically suspended) as well as
+ * that are neither blocked nor artificially suspended) as well as
* the total number. These two values are packed into one field,
* "workerCounts" because we need accurate snapshots when deciding
* to create, resume or suspend. Note however that the
- * correspondance of these counts to reality is not guaranteed. In
+ * correspondence of these counts to reality is not guaranteed. In
* particular updates for unblocked threads may lag until they
* actually wake up.
*
@@ -248,7 +266,7 @@ public class ForkJoinPool extends Abstra
* workers that previously could not find a task to now find one:
* Submission of a new task to the pool, or another worker pushing
* a task onto a previously empty queue. (We also use this
- * mechanism for termination and reconfiguration actions that
+ * mechanism for configuration and termination actions that
* require wakeups of idle workers). Each worker maintains its
* last known event count, and blocks when a scan for work did not
* find a task AND its lastEventCount matches the current
@@ -259,70 +277,66 @@ public class ForkJoinPool extends Abstra
* a record (field nextEventWaiter) for the next waiting worker.
* In addition to allowing simpler decisions about need for
* wakeup, the event count bits in eventWaiters serve the role of
- * tags to avoid ABA errors in Treiber stacks. To reduce delays
- * in task diffusion, workers not otherwise occupied may invoke
- * method releaseWaiters, that removes and signals (unparks)
- * workers not waiting on current count. To minimize task
- * production stalls associate with signalling, any worker pushing
- * a task on an empty queue invokes the weaker method signalWork,
- * that only releases idle workers until it detects interference
- * by other threads trying to release, and lets them take
- * over. The net effect is a tree-like diffusion of signals, where
- * released threads (and possibly others) help with unparks. To
- * further reduce contention effects a bit, failed CASes to
- * increment field eventCount are tolerated without retries.
+ * tags to avoid ABA errors in Treiber stacks. Upon any wakeup,
+ * released threads also try to release at most two others. The
+ * net effect is a tree-like diffusion of signals, where released
+ * threads (and possibly others) help with unparks. To further
+ * reduce contention effects a bit, failed CASes to increment
+ * field eventCount are tolerated without retries in signalWork.
* Conceptually they are merged into the same event, which is OK
* when their only purpose is to enable workers to scan for work.
*
- * 5. Managing suspension of extra workers. When a worker is about
- * to block waiting for a join (or via ManagedBlockers), we may
- * create a new thread to maintain parallelism level, or at least
- * avoid starvation. Usually, extra threads are needed for only
- * very short periods, yet join dependencies are such that we
- * sometimes need them in bursts. Rather than create new threads
- * each time this happens, we suspend no-longer-needed extra ones
- * as "spares". For most purposes, we don't distinguish "extra"
- * spare threads from normal "core" threads: On each call to
- * preStep (the only point at which we can do this) a worker
- * checks to see if there are now too many running workers, and if
- * so, suspends itself. Methods tryAwaitJoin and awaitBlocker
- * look for suspended threads to resume before considering
- * creating a new replacement. We don't need a special data
- * structure to maintain spares; simply scanning the workers array
- * looking for worker.isSuspended() is fine because the calling
- * thread is otherwise not doing anything useful anyway; we are at
- * least as happy if after locating a spare, the caller doesn't
- * actually block because the join is ready before we try to
- * adjust and compensate. Note that this is intrinsically racy.
- * One thread may become a spare at about the same time as another
- * is needlessly being created. We counteract this and related
- * slop in part by requiring resumed spares to immediately recheck
- * (in preStep) to see whether they they should re-suspend. The
- * only effective difference between "extra" and "core" threads is
- * that we allow the "extra" ones to time out and die if they are
- * not resumed within a keep-alive interval of a few seconds. This
- * is implemented mainly within ForkJoinWorkerThread, but requires
- * some coordination (isTrimmed() -- meaning killed while
- * suspended) to correctly maintain pool counts.
- *
- * 6. Deciding when to create new workers. The main dynamic
- * control in this class is deciding when to create extra threads,
- * in methods awaitJoin and awaitBlocker. We always need to create
- * one when the number of running threads would become zero and
- * all workers are busy. However, this is not easy to detect
- * reliably in the presence of transients so we use retries and
- * allow slack (in tryAwaitJoin) to reduce false alarms. These
- * effectively reduce churn at the price of systematically
- * undershooting target parallelism when many threads are blocked.
- * However, biasing toward undeshooting partially compensates for
- * the above mechanics to suspend extra threads, that normally
- * lead to overshoot because we can only suspend workers
- * in-between top-level actions. It also better copes with the
- * fact that some of the methods in this class tend to never
- * become compiled (but are interpreted), so some components of
- * the entire set of controls might execute many times faster than
- * others. And similarly for cases where the apparent lack of work
- * is just due to GC stalls and other transient system activity.
+ * 5. Managing suspension of extra workers. When a worker notices
+ * (usually upon timeout of a wait()) that there are too few
+ * running threads, we may create a new thread to maintain
+ * parallelism level, or at least avoid starvation. Usually, extra
+ * threads are needed for only very short periods, yet join
+ * dependencies are such that we sometimes need them in
+ * bursts. Rather than create new threads each time this happens,
+ * we suspend no-longer-needed extra ones as "spares". For most
+ * purposes, we don't distinguish "extra" spare threads from
+ * normal "core" threads: On each call to preStep (the only point
+ * at which we can do this) a worker checks to see if there are
+ * now too many running workers, and if so, suspends itself.
+ * Method helpMaintainParallelism looks for suspended threads to
+ * resume before considering creating a new replacement. The
+ * spares themselves are encoded on another variant of a Treiber
+ * Stack, headed at field "spareWaiters". Note that the use of
+ * spares is intrinsically racy. One thread may become a spare at
+ * about the same time as another is needlessly being created. We
+ * counteract this and related slop in part by requiring resumed
+ * spares to immediately recheck (in preStep) to see whether they
+ * should re-suspend.
+ *
+ * 6. Killing off unneeded workers. A timeout mechanism is used to
+ * shed unused workers: The oldest (first) event queue waiter uses
+ * a timed rather than hard wait. When this wait times out without
+ * a normal wakeup, it tries to shutdown any one (for convenience
+ * the newest) other spare or event waiter via
+ * tryShutdownUnusedWorker. This eventually reduces the number of
+ * worker threads to a minimum of one after a long enough period
+ * without use.
+ *
+ * 7. Deciding when to create new workers. The main dynamic
+ * control in this class is deciding when to create extra threads
+ * in method helpMaintainParallelism. We would like to keep
+ * exactly #parallelism threads running, which is an impossible
+ * task. We always need to create one when the number of running
+ * threads would become zero and all workers are busy. Beyond
+ * this, we must rely on heuristics that work well in the
+ * presence of transient phenomena such as GC stalls, dynamic
+ * compilation, and wake-up lags. These transients are extremely
+ * common -- we are normally trying to fully saturate the CPUs on
+ * a machine, so almost any activity other than running tasks
+ * impedes accuracy. Our main defense is to allow parallelism to
+ * lapse for a while during joins, and use a timeout to see if,
+ * after the resulting settling, there is still a need for
+ * additional workers. This also better copes with the fact that
+ * some of the methods in this class tend to never become compiled
+ * (but are interpreted), so some components of the entire set of
+ * controls might execute 100 times faster than others. And
+ * similarly for cases where the apparent lack of work is just due
+ * to GC stalls and other transient system activity.
*
* Beware that there is a lot of representation-level coupling
* among classes ForkJoinPool, ForkJoinWorkerThread, and
@@ -335,11 +349,13 @@ public class ForkJoinPool extends Abstra
*
* Style notes: There are lots of inline assignments (of form
* "while ((local = field) != 0)") which are usually the simplest
- * way to ensure read orderings. Also several occurrences of the
- * unusual "do {} while(!cas...)" which is the simplest way to
- * force an update of a CAS'ed variable. There are also other
- * coding oddities that help some methods perform reasonably even
- * when interpreted (not compiled), at the expense of messiness.
+ * way to ensure the required read orderings (which are sometimes
+ * critical). Also several occurrences of the unusual "do {}
+ * while (!cas...)" which is the simplest way to force an update of
+ * a CAS'ed variable. There are also other coding oddities that
+ * help some methods perform reasonably even when interpreted (not
+ * compiled), at the expense of some messy constructions that
+ * reduce byte code counts.
*
* The order of declarations in this file is: (1) statics (2)
* fields (along with constants used when unpacking some of them)
@@ -407,10 +423,33 @@ public class ForkJoinPool extends Abstra
new AtomicInteger();
/**
- * Absolute bound for parallelism level. Twice this number must
- * fit into a 16bit field to enable word-packing for some counts.
+ * The time to block in a join (see awaitJoin) before checking if
+ * a new worker should be (re)started to maintain parallelism
+ * level. The value should be short enough to maintain global
+ * responsiveness and progress but long enough to avoid
+ * counterproductive firings during GC stalls or unrelated system
+ * activity, and to not bog down systems with continual re-firings
+ * on GCs or legitimately long waits.
+ */
+ private static final long JOIN_TIMEOUT_MILLIS = 250L; // 4 per second
+
+ /**
+ * The wakeup interval (in nanoseconds) for the oldest worker
+ * waiting for an event to invoke tryShutdownUnusedWorker to
+ * shrink the number of workers. The exact value does not matter
+ * too much. It must be short enough to release resources during
+ * sustained periods of idleness, but not so short that threads
+ * are continually re-created.
+ */
+ private static final long SHRINK_RATE_NANOS =
+ 30L * 1000L * 1000L * 1000L; // 2 per minute
+
+ /**
+ * Absolute bound for parallelism level. Twice this number plus
+ * one (i.e., 0xfff) must fit into a 16bit field to enable
+ * word-packing for some counts and indices.
*/
- private static final int MAX_THREADS = 0x7fff;
+ private static final int MAX_WORKERS = 0x7fff;
/**
* Array holding all worker threads in the pool. Array size must
@@ -450,37 +489,52 @@ public class ForkJoinPool extends Abstra
private volatile long stealCount;
/**
- * Encoded record of top of treiber stack of threads waiting for
+ * Encoded record of top of Treiber stack of threads waiting for
* events. The top 32 bits contain the count being waited for. The
- * bottom word contains one plus the pool index of waiting worker
- * thread.
+ * bottom 16 bits contains one plus the pool index of waiting
+ * worker thread. (Bits 16-31 are unused.)
*/
private volatile long eventWaiters;
private static final int EVENT_COUNT_SHIFT = 32;
- private static final long WAITER_ID_MASK = (1L << EVENT_COUNT_SHIFT)-1L;
+ private static final long WAITER_ID_MASK = (1L << 16) - 1L;
/**
* A counter for events that may wake up worker threads:
* - Submission of a new task to the pool
* - A worker pushing a task on an empty queue
- * - termination and reconfiguration
+ * - termination
*/
private volatile int eventCount;
/**
+ * Encoded record of top of Treiber stack of spare threads waiting
+ * for resumption. The top 16 bits contain an arbitrary count to
+ * avoid ABA effects. The bottom 16bits contains one plus the pool
+ * index of waiting worker thread.
+ */
+ private volatile int spareWaiters;
+
+ private static final int SPARE_COUNT_SHIFT = 16;
+ private static final int SPARE_ID_MASK = (1 << 16) - 1;
+
+ /**
* Lifecycle control. The low word contains the number of workers
* that are (probably) executing tasks. This value is atomically
* incremented before a worker gets a task to run, and decremented
- * when worker has no tasks and cannot find any. Bits 16-18
+ * when a worker has no tasks and cannot find any. Bits 16-18
* contain runLevel value. When all are zero, the pool is
* running. Level transitions are monotonic (running -> shutdown
* -> terminating -> terminated) so each transition adds a bit.
* These are bundled together to ensure consistent read for
* termination checks (i.e., that runLevel is at least SHUTDOWN
* and active threads is zero).
+ *
+ * Notes: Most direct CASes are dependent on these bitfield
+ * positions. Also, this field is non-private to enable direct
+ * performance-sensitive CASes in ForkJoinWorkerThread.
*/
- private volatile int runState;
+ volatile int runState;
// Note: The order among run level values matters.
private static final int RUNLEVEL_SHIFT = 16;
@@ -488,7 +542,6 @@ public class ForkJoinPool extends Abstra
private static final int TERMINATING = 1 << (RUNLEVEL_SHIFT + 1);
private static final int TERMINATED = 1 << (RUNLEVEL_SHIFT + 2);
private static final int ACTIVE_COUNT_MASK = (1 << RUNLEVEL_SHIFT) - 1;
- private static final int ONE_ACTIVE = 1; // active update delta
/**
* Holds number of total (i.e., created and not yet terminated)
@@ -497,8 +550,7 @@ public class ForkJoinPool extends Abstra
* making decisions about creating and suspending spare
* threads. Updated only by CAS. Note that adding a new worker
* requires incrementing both counts, since workers start off in
- * running state. This field is also used for memory-fencing
- * configuration parameters.
+ * running state.
*/
private volatile int workerCounts;
@@ -530,11 +582,11 @@ public class ForkJoinPool extends Abstra
*/
private final int poolNumber;
- // Utilities for CASing fields. Note that several of these
- // are manually inlined by callers
+ // Utilities for CASing fields. Note that most of these
+ // are usually manually inlined by callers
/**
- * Increments running count. Also used by ForkJoinTask.
+ * Increments running count part of workerCounts
*/
final void incrementRunningCount() {
int c;
@@ -555,24 +607,25 @@ public class ForkJoinPool extends Abstra
}
/**
- * Tries to increment running count
- */
- final boolean tryIncrementRunningCount() {
- int wc;
- return UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc = workerCounts, wc + ONE_RUNNING);
- }
-
- /**
- * Tries incrementing active count; fails on contention.
- * Called by workers before executing tasks.
+ * Forces decrement of encoded workerCounts, awaiting nonzero if
+ * (rarely) necessary when other count updates lag.
*
- * @return true on success
+ * @param dr -- either zero or ONE_RUNNING
+ * @param dt -- either zero or ONE_TOTAL
*/
- final boolean tryIncrementActiveCount() {
- int c;
- return UNSAFE.compareAndSwapInt(this, runStateOffset,
- c = runState, c + ONE_ACTIVE);
+ private void decrementWorkerCounts(int dr, int dt) {
+ for (;;) {
+ int wc = workerCounts;
+ if ((wc & RUNNING_COUNT_MASK) - dr < 0 ||
+ (wc >>> TOTAL_COUNT_SHIFT) - dt < 0) {
+ if ((runState & TERMINATED) != 0)
+ return; // lagging termination on a backout
+ Thread.yield();
+ }
+ if (UNSAFE.compareAndSwapInt(this, workerCountsOffset,
+ wc, wc - (dr + dt)))
+ return;
+ }
}
/**
@@ -582,7 +635,7 @@ public class ForkJoinPool extends Abstra
final boolean tryDecrementActiveCount() {
int c;
return UNSAFE.compareAndSwapInt(this, runStateOffset,
- c = runState, c - ONE_ACTIVE);
+ c = runState, c - 1);
}
/**
@@ -611,12 +664,12 @@ public class ForkJoinPool extends Abstra
lock.lock();
try {
ForkJoinWorkerThread[] ws = workers;
- int nws = ws.length;
- if (k < 0 || k >= nws || ws[k] != null) {
- for (k = 0; k < nws && ws[k] != null; ++k)
+ int n = ws.length;
+ if (k < 0 || k >= n || ws[k] != null) {
+ for (k = 0; k < n && ws[k] != null; ++k)
;
- if (k == nws)
- ws = Arrays.copyOf(ws, nws << 1);
+ if (k == n)
+ ws = Arrays.copyOf(ws, n << 1);
}
ws[k] = w;
workers = ws; // volatile array write ensures slot visibility
@@ -627,11 +680,11 @@ public class ForkJoinPool extends Abstra
}
/**
- * Nulls out record of worker in workers array
+ * Nulls out record of worker in workers array.
*/
private void forgetWorker(ForkJoinWorkerThread w) {
int idx = w.poolIndex;
- // Locking helps method recordWorker avoid unecessary expansion
+ // Locking helps method recordWorker avoid unnecessary expansion
final ReentrantLock lock = this.workerLock;
lock.lock();
try {
@@ -643,462 +696,413 @@ public class ForkJoinPool extends Abstra
}
}
- // adding and removing workers
-
/**
- * Tries to create and add new worker. Assumes that worker counts
- * are already updated to accommodate the worker, so adjusts on
- * failure.
+ * Final callback from terminating worker. Removes record of
+ * worker from array, and adjusts counts. If pool is shutting
+ * down, tries to complete termination.
*
- * @return new worker or null if creation failed
+ * @param w the worker
*/
- private ForkJoinWorkerThread addWorker() {
- ForkJoinWorkerThread w = null;
- try {
- w = factory.newThread(this);
- } finally { // Adjust on either null or exceptional factory return
- if (w == null) {
- onWorkerCreationFailure();
- return null;
- }
- }
- w.start(recordWorker(w), ueh);
- return w;
+ final void workerTerminated(ForkJoinWorkerThread w) {
+ forgetWorker(w);
+ decrementWorkerCounts(w.isTrimmed() ? 0 : ONE_RUNNING, ONE_TOTAL);
+ while (w.stealCount != 0) // collect final count
+ tryAccumulateStealCount(w);
+ tryTerminate(false);
}
+ // Waiting for and signalling events
+
/**
- * Adjusts counts upon failure to create worker
+ * Releases workers blocked on a count not equal to current count.
+ * Normally called after precheck that eventWaiters isn't zero to
+ * avoid wasted array checks. Gives up upon a change in count or
+ * upon releasing two workers, letting others take over.
*/
- private void onWorkerCreationFailure() {
- for (;;) {
- int wc = workerCounts;
- if ((wc >>> TOTAL_COUNT_SHIFT) == 0)
- Thread.yield(); // wait for other counts to settle
- else if (UNSAFE.compareAndSwapInt(this, workerCountsOffset, wc,
- wc - (ONE_RUNNING|ONE_TOTAL)))
+ private void releaseEventWaiters() {
+ ForkJoinWorkerThread[] ws = workers;
+ int n = ws.length;
+ long h = eventWaiters;
+ int ec = eventCount;
+ boolean releasedOne = false;
+ ForkJoinWorkerThread w; int id;
+ while ((id = ((int)(h & WAITER_ID_MASK)) - 1) >= 0 &&
+ (int)(h >>> EVENT_COUNT_SHIFT) != ec &&
+ id < n && (w = ws[id]) != null) {
+ if (UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
+ h, w.nextWaiter)) {
+ LockSupport.unpark(w);
+ if (releasedOne) // exit on second release
+ break;
+ releasedOne = true;
+ }
+ if (eventCount != ec)
break;
+ h = eventWaiters;
}
- tryTerminate(false); // in case of failure during shutdown
}
/**
- * Creates and/or resumes enough workers to establish target
- * parallelism, giving up if terminating or addWorker fails
- *
- * TODO: recast this to support lazier creation and automated
- * parallelism maintenance
+ * Tries to advance eventCount and releases waiters. Called only
+ * from workers.
*/
- private void ensureEnoughWorkers() {
- while ((runState & TERMINATING) == 0) {
- int pc = parallelism;
- int wc = workerCounts;
- int rc = wc & RUNNING_COUNT_MASK;
- int tc = wc >>> TOTAL_COUNT_SHIFT;
- if (tc < pc) {
- if (UNSAFE.compareAndSwapInt
- (this, workerCountsOffset,
- wc, wc + (ONE_RUNNING|ONE_TOTAL)) &&
- addWorker() == null)
- break;
- }
- else if (tc > pc && rc < pc &&
- tc > (runState & ACTIVE_COUNT_MASK)) {
- ForkJoinWorkerThread spare = null;
- ForkJoinWorkerThread[] ws = workers;
- int nws = ws.length;
- for (int i = 0; i < nws; ++i) {
- ForkJoinWorkerThread w = ws[i];
- if (w != null && w.isSuspended()) {
- if ((workerCounts & RUNNING_COUNT_MASK) > pc)
- return;
- if (w.tryResumeSpare())
- incrementRunningCount();
- break;
- }
- }
- }
- else
- break;
- }
+ final void signalWork() {
+ int c; // try to increment event count -- CAS failure OK
+ UNSAFE.compareAndSwapInt(this, eventCountOffset, c = eventCount, c+1);
+ if (eventWaiters != 0L)
+ releaseEventWaiters();
}
/**
- * Final callback from terminating worker. Removes record of
- * worker from array, and adjusts counts. If pool is shutting
- * down, tries to complete terminatation, else possibly replaces
- * the worker.
+ * Adds the given worker to event queue and blocks until
+ * terminating or event count advances from the given value
*
- * @param w the worker
+ * @param w the calling worker thread
+ * @param ec the count
*/
- final void workerTerminated(ForkJoinWorkerThread w) {
- if (w.active) { // force inactive
- w.active = false;
- do {} while (!tryDecrementActiveCount());
- }
- forgetWorker(w);
-
- // Decrement total count, and if was running, running count
- // Spin (waiting for other updates) if either would be negative
- int nr = w.isTrimmed() ? 0 : ONE_RUNNING;
- int unit = ONE_TOTAL + nr;
- for (;;) {
- int wc = workerCounts;
- int rc = wc & RUNNING_COUNT_MASK;
- if (rc - nr < 0 || (wc >>> TOTAL_COUNT_SHIFT) == 0)
- Thread.yield(); // back off if waiting for other updates
- else if (UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - unit))
+ private void eventSync(ForkJoinWorkerThread w, int ec) {
+ long nh = (((long)ec) << EVENT_COUNT_SHIFT) | ((long)(w.poolIndex+1));
+ long h;
+ while ((runState < SHUTDOWN || !tryTerminate(false)) &&
+ (((int)((h = eventWaiters) & WAITER_ID_MASK)) == 0 ||
+ (int)(h >>> EVENT_COUNT_SHIFT) == ec) &&
+ eventCount == ec) {
+ if (UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
+ w.nextWaiter = h, nh)) {
+ awaitEvent(w, ec);
break;
+ }
}
-
- accumulateStealCount(w); // collect final count
- if (!tryTerminate(false))
- ensureEnoughWorkers();
}
- // Waiting for and signalling events
-
/**
- * Releases workers blocked on a count not equal to current count.
- * @return true if any released
+ * Blocks the given worker (that has already been entered as an
+ * event waiter) until terminating or event count advances from
+ * the given value. The oldest (first) waiter uses a timed wait to
+ * occasionally one-by-one shrink the number of workers (to a
+ * minimum of one) if the pool has not been used for extended
+ * periods.
+ *
+ * @param w the calling worker thread
+ * @param ec the count
*/
- private void releaseWaiters() {
- long top;
- while ((top = eventWaiters) != 0L) {
- ForkJoinWorkerThread[] ws = workers;
- int n = ws.length;
- for (;;) {
- int i = ((int)(top & WAITER_ID_MASK)) - 1;
- if (i < 0 || (int)(top >>> EVENT_COUNT_SHIFT) == eventCount)
- return;
- ForkJoinWorkerThread w;
- if (i < n && (w = ws[i]) != null &&
- UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
- top, w.nextWaiter)) {
- LockSupport.unpark(w);
- top = eventWaiters;
+ private void awaitEvent(ForkJoinWorkerThread w, int ec) {
+ while (eventCount == ec) {
+ if (tryAccumulateStealCount(w)) { // transfer while idle
+ boolean untimed = (w.nextWaiter != 0L ||
+ (workerCounts & RUNNING_COUNT_MASK) <= 1);
+ long startTime = untimed ? 0 : System.nanoTime();
+ Thread.interrupted(); // clear/ignore interrupt
+ if (eventCount != ec || w.isTerminating())
+ break; // recheck after clear
+ if (untimed)
+ LockSupport.park(w);
+ else {
+ LockSupport.parkNanos(w, SHRINK_RATE_NANOS);
+ if (eventCount != ec || w.isTerminating())
+ break;
+ if (System.nanoTime() - startTime >= SHRINK_RATE_NANOS)
+ tryShutdownUnusedWorker(ec);
}
- else
- break; // possibly stale; reread
}
}
}
+ // Maintaining parallelism
+
/**
- * Ensures eventCount on exit is different (mod 2^32) than on
- * entry and wakes up all waiters
+ * Pushes worker onto the spare stack.
*/
- private void signalEvent() {
- int c;
- do {} while (!UNSAFE.compareAndSwapInt(this, eventCountOffset,
- c = eventCount, c+1));
- releaseWaiters();
+ final void pushSpare(ForkJoinWorkerThread w) {
+ int ns = (++w.spareCount << SPARE_COUNT_SHIFT) | (w.poolIndex + 1);
+ do {} while (!UNSAFE.compareAndSwapInt(this, spareWaitersOffset,
+ w.nextSpare = spareWaiters,ns));
}
/**
- * Advances eventCount and releases waiters until interference by
- * other releasing threads is detected.
+ * Tries (once) to resume a spare if the number of running
+ * threads is less than target.
*/
- final void signalWork() {
- int c;
- UNSAFE.compareAndSwapInt(this, eventCountOffset, c=eventCount, c+1);
- long top;
- while ((top = eventWaiters) != 0L) {
- int ec = eventCount;
- ForkJoinWorkerThread[] ws = workers;
- int n = ws.length;
- for (;;) {
- int i = ((int)(top & WAITER_ID_MASK)) - 1;
- if (i < 0 || (int)(top >>> EVENT_COUNT_SHIFT) == ec)
- return;
- ForkJoinWorkerThread w;
- if (i < n && (w = ws[i]) != null &&
- UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
- top, top = w.nextWaiter)) {
- LockSupport.unpark(w);
- if (top != eventWaiters) // let someone else take over
- return;
- }
- else
- break; // possibly stale; reread
- }
+ private void tryResumeSpare() {
+ int sw, id;
+ ForkJoinWorkerThread[] ws = workers;
+ int n = ws.length;
+ ForkJoinWorkerThread w;
+ if ((sw = spareWaiters) != 0 &&
+ (id = (sw & SPARE_ID_MASK) - 1) >= 0 &&
+ id < n && (w = ws[id]) != null &&
+ (workerCounts & RUNNING_COUNT_MASK) < parallelism &&
+ spareWaiters == sw &&
+ UNSAFE.compareAndSwapInt(this, spareWaitersOffset,
+ sw, w.nextSpare)) {
+ int c; // increment running count before resume
+ do {} while (!UNSAFE.compareAndSwapInt
+ (this, workerCountsOffset,
+ c = workerCounts, c + ONE_RUNNING));
+ if (w.tryUnsuspend())
+ LockSupport.unpark(w);
+ else // back out if w was shutdown
+ decrementWorkerCounts(ONE_RUNNING, 0);
}
}
/**
- * If worker is inactive, blocks until terminating or event count
- * advances from last value held by worker; in any case helps
- * release others.
- *
- * @param w the calling worker thread
- * @param retries the number of scans by caller failing to find work
- * @return false if now too many threads running
+ * Tries to increase the number of running workers if below target
+ * parallelism: If a spare exists tries to resume it via
+ * tryResumeSpare. Otherwise, if not enough total workers or all
+ * existing workers are busy, adds a new worker. In all cases also
+ * helps wake up releasable workers waiting for work.
*/
- private boolean eventSync(ForkJoinWorkerThread w, int retries) {
- int wec = w.lastEventCount;
- if (retries > 1) { // can only block after 2nd miss
- long nextTop = (((long)wec << EVENT_COUNT_SHIFT) |
- ((long)(w.poolIndex + 1)));
- long top;
- while ((runState < SHUTDOWN || !tryTerminate(false)) &&
- (((int)(top = eventWaiters) & WAITER_ID_MASK) == 0 ||
- (int)(top >>> EVENT_COUNT_SHIFT) == wec) &&
- eventCount == wec) {
- if (UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
- w.nextWaiter = top, nextTop)) {
- accumulateStealCount(w); // transfer steals while idle
- Thread.interrupted(); // clear/ignore interrupt
- while (eventCount == wec)
- w.doPark();
+ private void helpMaintainParallelism() {
+ int pc = parallelism;
+ int wc, rs, tc;
+ while (((wc = workerCounts) & RUNNING_COUNT_MASK) < pc &&
+ (rs = runState) < TERMINATING) {
+ if (spareWaiters != 0)
+ tryResumeSpare();
+ else if ((tc = wc >>> TOTAL_COUNT_SHIFT) >= MAX_WORKERS ||
+ (tc >= pc && (rs & ACTIVE_COUNT_MASK) != tc))
+ break; // enough total
+ else if (runState == rs && workerCounts == wc &&
+ UNSAFE.compareAndSwapInt(this, workerCountsOffset, wc,
+ wc + (ONE_RUNNING|ONE_TOTAL))) {
+ ForkJoinWorkerThread w = null;
+ Throwable fail = null;
+ try {
+ w = factory.newThread(this);
+ } catch (Throwable ex) {
+ fail = ex;
+ }
+ if (w == null) { // null or exceptional factory return
+ decrementWorkerCounts(ONE_RUNNING, ONE_TOTAL);
+ tryTerminate(false); // handle failure during shutdown
+ // If originating from an external caller,
+ // propagate exception, else ignore
+ if (fail != null && runState < TERMINATING &&
+ !(Thread.currentThread() instanceof
+ ForkJoinWorkerThread))
+ UNSAFE.throwException(fail);
break;
}
+ w.start(recordWorker(w), ueh);
+ if ((workerCounts >>> TOTAL_COUNT_SHIFT) >= pc) {
+ int c; // advance event count
+ UNSAFE.compareAndSwapInt(this, eventCountOffset,
+ c = eventCount, c+1);
+ break; // add at most one unless total below target
+ }
}
- wec = eventCount;
}
- releaseWaiters();
- int wc = workerCounts;
- if ((wc & RUNNING_COUNT_MASK) <= parallelism) {
- w.lastEventCount = wec;
- return true;
+ if (eventWaiters != 0L)
+ releaseEventWaiters();
+ }
+
+ /**
+ * Callback from the oldest waiter in awaitEvent waking up after a
+ * period of non-use. If all workers are idle, tries (once) to
+ * shutdown an event waiter or a spare, if one exists. Note that
+ * we don't need CAS or locks here because the method is called
+ * only from one thread occasionally waking (and even misfires are
+ * OK). Note that until the shutdown worker fully terminates,
+ * workerCounts will overestimate total count, which is tolerable.
+ *
+ * @param ec the event count waited on by caller (to abort
+ * attempt if count has since changed).
+ */
+ private void tryShutdownUnusedWorker(int ec) {
+ if (runState == 0 && eventCount == ec) { // only trigger if all idle
+ ForkJoinWorkerThread[] ws = workers;
+ int n = ws.length;
+ ForkJoinWorkerThread w = null;
+ boolean shutdown = false;
+ int sw;
+ long h;
+ if ((sw = spareWaiters) != 0) { // prefer killing spares
+ int id = (sw & SPARE_ID_MASK) - 1;
+ if (id >= 0 && id < n && (w = ws[id]) != null &&
+ UNSAFE.compareAndSwapInt(this, spareWaitersOffset,
+ sw, w.nextSpare))
+ shutdown = true;
+ }
+ else if ((h = eventWaiters) != 0L) {
+ long nh;
+ int id = ((int)(h & WAITER_ID_MASK)) - 1;
+ if (id >= 0 && id < n && (w = ws[id]) != null &&
+ (nh = w.nextWaiter) != 0L && // keep at least one worker
+ UNSAFE.compareAndSwapLong(this, eventWaitersOffset, h, nh))
+ shutdown = true;
+ }
+ if (w != null && shutdown) {
+ w.shutdown();
+ LockSupport.unpark(w);
+ }
}
- if (wec != w.lastEventCount) // back up if may re-wait
- w.lastEventCount = wec - (wc >>> TOTAL_COUNT_SHIFT);
- return false;
+ releaseEventWaiters(); // in case of interference
}
/**
* Callback from workers invoked upon each top-level action (i.e.,
- * stealing a task or taking a submission and running
- * it). Performs one or both of the following:
+ * stealing a task or taking a submission and running it).
+ * Performs one or more of the following:
*
- * * If the worker cannot find work, updates its active status to
- * inactive and updates activeCount unless there is contention, in
- * which case it may try again (either in this or a subsequent
- * call). Additionally, awaits the next task event and/or helps
- * wake up other releasable waiters.
- *
- * * If there are too many running threads, suspends this worker
- * (first forcing inactivation if necessary). If it is not
- * resumed before a keepAlive elapses, the worker may be "trimmed"
- * -- killed while suspended within suspendAsSpare. Otherwise,
- * upon resume it rechecks to make sure that it is still needed.
+ * 1. If the worker is active and either did not run a task
+ * or there are too many workers, try to set its active status
+ * to inactive and update activeCount. On contention, we may
+ * try again in this or a subsequent call.
+ *
+ * 2. If not enough total workers, help create some.
+ *
+ * 3. If there are too many running workers, suspend this worker
+ * (first forcing inactive if necessary). If it is not needed,
+ * it may be shutdown while suspended (via
+ * tryShutdownUnusedWorker). Otherwise, upon resume it
+ * rechecks running thread count and need for event sync.
+ *
+ * 4. If worker did not run a task, await the next task event via
+ * eventSync if necessary (first forcing inactivation), upon
+ * which the worker may be shutdown via
+ * tryShutdownUnusedWorker. Otherwise, help release any
+ * existing event waiters that are now releasable,
*
* @param w the worker
- * @param retries the number of scans by caller failing to find work
- * find any (in which case it may block waiting for work).
+ * @param ran true if worker ran a task since last call to this method
*/
- final void preStep(ForkJoinWorkerThread w, int retries) {
+ final void preStep(ForkJoinWorkerThread w, boolean ran) {
+ int wec = w.lastEventCount;
boolean active = w.active;
- boolean inactivate = active && retries != 0;
- for (;;) {
- int rs, wc;
- if (inactivate &&
- UNSAFE.compareAndSwapInt(this, runStateOffset,
- rs = runState, rs - ONE_ACTIVE))
+ boolean inactivate = false;
+ int pc = parallelism;
+ while (w.runState == 0) {
+ int rs = runState;
+ if (rs >= TERMINATING) { // propagate shutdown
+ w.shutdown();
+ break;
+ }
+ if ((inactivate || (active && (rs & ACTIVE_COUNT_MASK) >= pc)) &&
+ UNSAFE.compareAndSwapInt(this, runStateOffset, rs, rs - 1))
inactivate = active = w.active = false;
- if (((wc = workerCounts) & RUNNING_COUNT_MASK) <= parallelism) {
- if (active || eventSync(w, retries))
+ int wc = workerCounts;
+ if ((wc & RUNNING_COUNT_MASK) > pc) {
+ if (!(inactivate |= active) && // must inactivate to suspend
+ workerCounts == wc && // try to suspend as spare
+ UNSAFE.compareAndSwapInt(this, workerCountsOffset,
+ wc, wc - ONE_RUNNING))
+ w.suspendAsSpare();
+ }
+ else if ((wc >>> TOTAL_COUNT_SHIFT) < pc)
+ helpMaintainParallelism(); // not enough workers
+ else if (!ran) {
+ long h = eventWaiters;
+ int ec = eventCount;
+ if (h != 0L && (int)(h >>> EVENT_COUNT_SHIFT) != ec)
+ releaseEventWaiters(); // release others before waiting
+ else if (ec != wec) {
+ w.lastEventCount = ec; // no need to wait
break;
+ }
+ else if (!(inactivate |= active))
+ eventSync(w, wec); // must inactivate before sync
}
- else if (!(inactivate |= active) && // must inactivate to suspend
- UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - ONE_RUNNING) &&
- !w.suspendAsSpare()) // false if trimmed
+ else
break;
}
}
/**
- * Awaits join of the given task if enough threads, or can resume
- * or create a spare. Fails (in which case the given task might
- * not be done) upon contention or lack of decision about
- * blocking. Returns void because caller must check
- * task status on return anyway.
- *
- * We allow blocking if:
- *
- * 1. There would still be at least as many running threads as
- * parallelism level if this thread blocks.
- *
- * 2. A spare is resumed to replace this worker. We tolerate
- * slop in the decision to replace if a spare is found without
- * first decrementing run count. This may release too many,
- * but if so, the superfluous ones will re-suspend via
- * preStep().
- *
- * 3. After #spares repeated checks, there are no fewer than #spare
- * threads not running. We allow this slack to avoid hysteresis
- * and as a hedge against lag/uncertainty of running count
- * estimates when signalling or unblocking stalls.
- *
- * 4. All existing workers are busy (as rechecked via repeated
- * retries by caller) and a new spare is created.
- *
- * If none of the above hold, we try to escape out by
- * re-incrementing count and returning to caller, which can retry
- * later.
+ * Helps and/or blocks awaiting join of the given task.
+ * See above for explanation.
*
* @param joinMe the task to join
- * @param retries if negative, then serve only as a precheck
- * that the thread can be replaced by a spare. Otherwise,
- * the number of repeated calls to this method returning busy
- * @return true if the call must be retried because there
- * none of the blocking checks hold
- */
- final boolean tryAwaitJoin(ForkJoinTask joinMe, int retries) {
- if (joinMe.status < 0) // precheck for cancellation
- return false;
- if ((runState & TERMINATING) != 0) { // shutting down
- joinMe.cancelIgnoringExceptions();
- return false;
- }
-
- int pc = parallelism;
- boolean running = true; // false when running count decremented
- outer:for (;;) {
- int wc = workerCounts;
- int rc = wc & RUNNING_COUNT_MASK;
- int tc = wc >>> TOTAL_COUNT_SHIFT;
- if (running) { // replace with spare or decrement count
- if (rc <= pc && tc > pc &&
- (retries > 0 || tc > (runState & ACTIVE_COUNT_MASK))) {
- ForkJoinWorkerThread[] ws = workers;
- int nws = ws.length;
- for (int i = 0; i < nws; ++i) { // search for spare
- ForkJoinWorkerThread w = ws[i];
- if (w != null) {
- if (joinMe.status < 0)
- return false;
- if (w.isSuspended()) {
- if ((workerCounts & RUNNING_COUNT_MASK)>=pc &&
- w.tryResumeSpare()) {
- running = false;
- break outer;
- }
- continue outer; // rescan
+ * @param worker the current worker thread
+ * @param timed true if wait should time out
+ * @param nanos timeout value if timed
+ */
+ final void awaitJoin(ForkJoinTask joinMe, ForkJoinWorkerThread worker,
+ boolean timed, long nanos) {
+ long startTime = timed? System.nanoTime() : 0L;
+ int retries = 2 + (parallelism >> 2); // #helpJoins before blocking
+ while (joinMe.status >= 0) {
+ int wc;
+ long nt = 0L;
+ if (runState >= TERMINATING) {
+ joinMe.cancelIgnoringExceptions();
+ break;
+ }
+ worker.helpJoinTask(joinMe);
+ if (joinMe.status < 0)
+ break;
+ else if (retries > 0)
+ --retries;
+ else if (timed &&
+ (nt = nanos - (System.nanoTime() - startTime)) <= 0L)
+ break;
+ else if (((wc = workerCounts) & RUNNING_COUNT_MASK) != 0 &&
+ UNSAFE.compareAndSwapInt(this, workerCountsOffset,
+ wc, wc - ONE_RUNNING)) {
+ int stat, c; long h;
+ while ((stat = joinMe.status) >= 0 &&
+ (h = eventWaiters) != 0L && // help release others
+ (int)(h >>> EVENT_COUNT_SHIFT) != eventCount)
+ releaseEventWaiters();
+ if (stat >= 0) {
+ if ((workerCounts & RUNNING_COUNT_MASK) != 0) {
+ long ms; int ns;
+ if (!timed) {
+ ms = JOIN_TIMEOUT_MILLIS;
+ ns = 0;
+ }
+ else { // at most JOIN_TIMEOUT_MILLIS per wait
+ ms = nt / 1000000;
+ if (ms > JOIN_TIMEOUT_MILLIS) {
+ ms = JOIN_TIMEOUT_MILLIS;
+ ns = 0;
}
+ else
+ ns = (int) (nt % 1000000);
}
+ stat = joinMe.internalAwaitDone(ms, ns);
}
+ if (stat >= 0) // timeout or no running workers
+ helpMaintainParallelism();
}
- if (retries < 0 || // < 0 means replacement check only
- rc == 0 || joinMe.status < 0 || workerCounts != wc ||
- !UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - ONE_RUNNING))
- return false; // done or inconsistent or contended
- running = false;
- if (rc > pc)
- break;
- }
- else { // allow blocking if enough threads
- if (rc >= pc || joinMe.status < 0)
- break;
- int sc = tc - pc + 1; // = spare threads, plus the one to add
- if (retries > sc) {
- if (rc > 0 && rc >= pc - sc) // allow slack
- break;
- if (tc < MAX_THREADS &&
- tc == (runState & ACTIVE_COUNT_MASK) &&
- workerCounts == wc &&
- UNSAFE.compareAndSwapInt(this, workerCountsOffset, wc,
- wc+(ONE_RUNNING|ONE_TOTAL))) {
- addWorker();
- break;
- }
- }
- if (workerCounts == wc && // back out to allow rescan
- UNSAFE.compareAndSwapInt (this, workerCountsOffset,
- wc, wc + ONE_RUNNING)) {
- releaseWaiters(); // help others progress
- return true; // let caller retry
- }
+ do {} while (!UNSAFE.compareAndSwapInt
+ (this, workerCountsOffset,
+ c = workerCounts, c + ONE_RUNNING));
+ if (stat < 0)
+ break; // else restart
}
}
- // arrive here if can block
- joinMe.internalAwaitDone();
- int c; // to inline incrementRunningCount
- do {} while (!UNSAFE.compareAndSwapInt
- (this, workerCountsOffset,
- c = workerCounts, c + ONE_RUNNING));
- return false;
}
/**
- * Same idea as (and shares many code snippets with) tryAwaitJoin,
- * but self-contained because there are no caller retries.
- * TODO: Rework to use simpler API.
+ * Same idea as awaitJoin, but no helping, retries, or timeouts.
*/
final void awaitBlocker(ManagedBlocker blocker)
throws InterruptedException {
- boolean done;
- if (done = blocker.isReleasable())
- return;
- int pc = parallelism;
- int retries = 0;
- boolean running = true; // false when running count decremented
- outer:for (;;) {
+ while (!blocker.isReleasable()) {
int wc = workerCounts;
- int rc = wc & RUNNING_COUNT_MASK;
- int tc = wc >>> TOTAL_COUNT_SHIFT;
- if (running) {
- if (rc <= pc && tc > pc &&
- (retries > 0 || tc > (runState & ACTIVE_COUNT_MASK))) {
- ForkJoinWorkerThread[] ws = workers;
- int nws = ws.length;
- for (int i = 0; i < nws; ++i) {
- ForkJoinWorkerThread w = ws[i];
- if (w != null) {
- if (done = blocker.isReleasable())
- return;
- if (w.isSuspended()) {
- if ((workerCounts & RUNNING_COUNT_MASK)>=pc &&
- w.tryResumeSpare()) {
- running = false;
- break outer;
- }
- continue outer; // rescan
- }
- }
- }
- }
- if (done = blocker.isReleasable())
- return;
- if (rc == 0 || workerCounts != wc ||
- !UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - ONE_RUNNING))
- continue;
- running = false;
- if (rc > pc)
- break;
- }
- else {
- if (rc >= pc || (done = blocker.isReleasable()))
- break;
- int sc = tc - pc + 1;
- if (retries++ > sc) {
- if (rc > 0 && rc >= pc - sc)
- break;
- if (tc < MAX_THREADS &&
- tc == (runState & ACTIVE_COUNT_MASK) &&
- workerCounts == wc &&
- UNSAFE.compareAndSwapInt(this, workerCountsOffset, wc,
- wc+(ONE_RUNNING|ONE_TOTAL))) {
- addWorker();
- break;
+ if ((wc & RUNNING_COUNT_MASK) != 0 &&
+ UNSAFE.compareAndSwapInt(this, workerCountsOffset,
+ wc, wc - ONE_RUNNING)) {
+ try {
+ while (!blocker.isReleasable()) {
+ long h = eventWaiters;
+ if (h != 0L &&
+ (int)(h >>> EVENT_COUNT_SHIFT) != eventCount)
+ releaseEventWaiters();
+ else if ((workerCounts & RUNNING_COUNT_MASK) == 0 &&
+ runState < TERMINATING)
+ helpMaintainParallelism();
+ else if (blocker.block())
+ break;
}
+ } finally {
+ int c;
+ do {} while (!UNSAFE.compareAndSwapInt
+ (this, workerCountsOffset,
+ c = workerCounts, c + ONE_RUNNING));
}
- Thread.yield();
- }
- }
-
- try {
- if (!done)
- do {} while (!blocker.isReleasable() && !blocker.block());
- } finally {
- if (!running) {
- int c;
- do {} while (!UNSAFE.compareAndSwapInt
- (this, workerCountsOffset,
- c = workerCounts, c + ONE_RUNNING));
+ break;
}
}
}
@@ -1129,21 +1133,44 @@ public class ForkJoinPool extends Abstra
return true;
}
+
/**
* Actions on transition to TERMINATING
+ *
+ * Runs up to four passes through workers: (0) shutting down each
+ * (without waking up if parked) to quickly spread notifications
+ * without unnecessary bouncing around event queues etc (1) wake
+ * up and help cancel tasks (2) interrupt (3) mop up races with
+ * interrupted workers
*/
private void startTerminating() {
- for (int i = 0; i < 2; ++i) { // twice to mop up newly created workers
- cancelSubmissions();
- shutdownWorkers();
- cancelWorkerTasks();
- signalEvent();
- interruptWorkers();
+ cancelSubmissions();
+ for (int passes = 0; passes < 4 && workerCounts != 0; ++passes) {
+ int c; // advance event count
+ UNSAFE.compareAndSwapInt(this, eventCountOffset,
+ c = eventCount, c+1);
+ eventWaiters = 0L; // clobber lists
+ spareWaiters = 0;
+ for (ForkJoinWorkerThread w : workers) {
+ if (w != null) {
+ w.shutdown();
+ if (passes > 0 && !w.isTerminated()) {
+ w.cancelTasks();
+ LockSupport.unpark(w);
+ if (passes > 1 && !w.isInterrupted()) {
+ try {
+ w.interrupt();
+ } catch (SecurityException ignore) {
+ }
+ }
+ }
+ }
+ }
}
}
/**
- * Clear out and cancel submissions, ignoring exceptions
+ * Clears out and cancels submissions, ignoring exceptions.
*/
private void cancelSubmissions() {
ForkJoinTask task;
@@ -1155,71 +1182,31 @@ public class ForkJoinPool extends Abstra
}
}
- /**
- * Sets all worker run states to at least shutdown,
- * also resuming suspended workers
- */
- private void shutdownWorkers() {
- ForkJoinWorkerThread[] ws = workers;
- int nws = ws.length;
- for (int i = 0; i < nws; ++i) {
- ForkJoinWorkerThread w = ws[i];
- if (w != null)
- w.shutdown();
- }
- }
-
- /**
- * Clears out and cancels all locally queued tasks
- */
- private void cancelWorkerTasks() {
- ForkJoinWorkerThread[] ws = workers;
- int nws = ws.length;
- for (int i = 0; i < nws; ++i) {
- ForkJoinWorkerThread w = ws[i];
- if (w != null)
- w.cancelTasks();
- }
- }
-
- /**
- * Unsticks all workers blocked on joins etc
- */
- private void interruptWorkers() {
- ForkJoinWorkerThread[] ws = workers;
- int nws = ws.length;
- for (int i = 0; i < nws; ++i) {
- ForkJoinWorkerThread w = ws[i];
- if (w != null && !w.isTerminated()) {
- try {
- w.interrupt();
- } catch (SecurityException ignore) {
- }
- }
- }
- }
-
// misc support for ForkJoinWorkerThread
/**
- * Returns pool number
+ * Returns pool number.
*/
final int getPoolNumber() {
return poolNumber;
}
/**
- * Accumulates steal count from a worker, clearing
- * the worker's value
+ * Tries to accumulate steal count from a worker, clearing
+ * the worker's value if successful.
+ *
+ * @return true if worker steal count now zero
*/
- final void accumulateStealCount(ForkJoinWorkerThread w) {
+ final boolean tryAccumulateStealCount(ForkJoinWorkerThread w) {
int sc = w.stealCount;
- if (sc != 0) {
- long c;
- w.stealCount = 0;
- do {} while (!UNSAFE.compareAndSwapLong(this, stealCountOffset,
- c = stealCount, c + sc));
+ long c = stealCount;
+ // CAS even if zero, for fence effects
+ if (UNSAFE.compareAndSwapLong(this, stealCountOffset, c, c + sc)) {
+ if (sc != 0)
+ w.stealCount = 0;
+ return true;
}
+ return sc == 0;
}
/**
@@ -1228,9 +1215,12 @@ public class ForkJoinPool extends Abstra
*/
final int idlePerActive() {
int pc = parallelism; // use parallelism, not rc
- int ac = runState; // no mask -- artifically boosts during shutdown
+ int ac = runState; // no mask -- artificially boosts during shutdown
// Use exact results for small values, saturate past 4
- return pc <= ac? 0 : pc >>> 1 <= ac? 1 : pc >>> 2 <= ac? 3 : pc >>> 3;
+ return ((pc <= ac) ? 0 :
+ (pc >>> 1 <= ac) ? 1 :
+ (pc >>> 2 <= ac) ? 3 :
+ pc >>> 3);
}
// Public and protected methods
@@ -1280,13 +1270,13 @@ public class ForkJoinPool extends Abstra
* 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 A {@code ManagedBlocker} provides two methods.
- * Method {@code isReleasable} must return {@code true} if
- * blocking is not necessary. Method {@code block} blocks the
- * current thread if necessary (perhaps internally invoking
- * {@code isReleasable} before actually blocking).
+ * A {@code ManagedBlocker} provides two methods. Method
+ * {@code isReleasable} must return {@code true} if blocking is
+ * not necessary. Method {@code block} blocks the current thread
+ * if necessary (perhaps internally invoking {@code isReleasable}
+ * before actually blocking). The unusual methods in this API
+ * accommodate synchronizers that may, but don't usually, block
+ * for long periods. Similarly, they allow more efficient internal
+ * handling of cases in which additional workers may be, but
+ * usually are not, needed to ensure sufficient parallelism.
+ * Toward this end, implementations of method {@code isReleasable}
+ * must be amenable to repeated invocation.
*
* For example, here is a ManagedBlocker based on a
* ReentrantLock:
@@ -1831,6 +1834,26 @@ public class ForkJoinPool extends Abstra
* return hasLock || (hasLock = lock.tryLock());
* }
* }}
+ *
+ * Here is a class that possibly blocks waiting for an
+ * item on a given queue:
+ * null.
+ * 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 false.
+ * 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
@@ -1302,7 +1292,7 @@ public class ForkJoinPool extends Abstra
checkPermission();
if (factory == null)
throw new NullPointerException();
- if (parallelism <= 0 || parallelism > MAX_THREADS)
+ if (parallelism <= 0 || parallelism > MAX_WORKERS)
throw new IllegalArgumentException();
this.parallelism = parallelism;
this.factory = factory;
@@ -1321,8 +1311,9 @@ public class ForkJoinPool extends Abstra
* @param pc the initial parallelism level
*/
private static int initialArraySizeFor(int pc) {
- // See Hackers Delight, sec 3.2. We know MAX_THREADS < (1 >>> 16)
- int size = pc < MAX_THREADS ? pc + 1 : MAX_THREADS;
+ // If possible, initially allocate enough space for one spare
+ int size = pc < MAX_WORKERS ? pc + 1 : MAX_WORKERS;
+ // See Hackers Delight, sec 3.2. We know MAX_WORKERS < (1 >>> 16)
size |= size >>> 1;
size |= size >>> 2;
size |= size >>> 4;
@@ -1333,23 +1324,17 @@ public class ForkJoinPool extends Abstra
// Execution methods
/**
- * Common code for execute, invoke and submit
+ * Submits task and creates, starts, or resumes some workers if necessary
*/
private {@code
+ * class QueueTaker
*/
public static interface ManagedBlocker {
/**
@@ -1873,8 +1896,10 @@ public class ForkJoinPool extends Abstra
public static void managedBlock(ManagedBlocker blocker)
throws InterruptedException {
Thread t = Thread.currentThread();
- if (t instanceof ForkJoinWorkerThread)
- ((ForkJoinWorkerThread) t).pool.awaitBlocker(blocker);
+ if (t instanceof ForkJoinWorkerThread) {
+ ForkJoinWorkerThread w = (ForkJoinWorkerThread) t;
+ w.pool.awaitBlocker(blocker);
+ }
else {
do {} while (!blocker.isReleasable() && !blocker.block());
}
@@ -1902,9 +1927,11 @@ public class ForkJoinPool extends Abstra
private static final long eventCountOffset =
objectFieldOffset("eventCount", ForkJoinPool.class);
private static final long eventWaitersOffset =
- objectFieldOffset("eventWaiters",ForkJoinPool.class);
+ objectFieldOffset("eventWaiters", ForkJoinPool.class);
private static final long stealCountOffset =
- objectFieldOffset("stealCount",ForkJoinPool.class);
+ objectFieldOffset("stealCount", ForkJoinPool.class);
+ private static final long spareWaitersOffset =
+ objectFieldOffset("spareWaiters", ForkJoinPool.class);
private static long objectFieldOffset(String field, Class klazz) {
try {