A {@code ForkJoinPool} differs from other kinds of {@link @@ -30,33 +30,19 @@ import java.util.concurrent.CountDownLat * execute subtasks created by other active tasks (eventually blocking * waiting for work if none exist). This enables efficient processing * when most tasks spawn other subtasks (as do most {@code - * ForkJoinTask}s). A {@code ForkJoinPool} may also be used for mixed - * execution of some plain {@code Runnable}- or {@code Callable}- - * based activities along with {@code ForkJoinTask}s. When setting - * {@linkplain #setAsyncMode async mode}, a {@code ForkJoinPool} may - * also be appropriate for use with fine-grained tasks of any form - * that are never joined. Otherwise, other {@code ExecutorService} - * implementations are typically more appropriate choices. + * ForkJoinTask}s). When setting asyncMode to true in + * constructors, {@code ForkJoinPool}s may also be appropriate for use + * with event-style tasks that are never joined. * *
A {@code ForkJoinPool} is constructed with a given target * parallelism level; by default, equal to the number of available - * processors. Unless configured otherwise via {@link - * #setMaintainsParallelism}, the pool attempts to maintain this - * number of active (or available) threads by dynamically adding, - * suspending, or resuming internal worker threads, even if some tasks - * are stalled waiting to join others. However, no such adjustments - * are performed in the face of blocked IO or other unmanaged - * synchronization. The nested {@link ManagedBlocker} interface - * enables extension of the kinds of synchronization accommodated. - * The target parallelism level may also be changed dynamically - * ({@link #setParallelism}). The total number of threads may be - * limited using method {@link #setMaximumPoolSize}, in which case it - * may become possible for the activities of a pool to stall due to - * the lack of available threads to process new tasks. When the pool - * is executing tasks, these and other configuration setting methods - * may only gradually affect actual pool sizes. It is normally best - * practice to invoke these methods only when the pool is known to be - * quiescent. + * processors. The pool attempts to maintain enough active (or + * available) threads by dynamically adding, suspending, or resuming + * internal worker threads, even if some tasks are stalled waiting to + * join others. However, no such adjustments are guaranteed in the + * face of blocked IO or other unmanaged synchronization. The nested + * {@link ManagedBlocker} interface enables extension of the kinds of + * synchronization accommodated. * *
In addition to execution and lifecycle control methods, this * class provides status check methods (for example @@ -65,6 +51,40 @@ import java.util.concurrent.CountDownLat * {@link #toString} returns indications of pool state in a * convenient form for informal monitoring. * + *
As is the case with other ExecutorServices, there are three + * main task execution methods summarized in the follwoing + * 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 + * overloaded forms also allow mixed execution of plain {@code + * Runnable}- or {@code Callable}- based activities as well. However, + * tasks that are already executing in a pool should normally + * NOT use these pool execution methods, but instead use the + * within-computation forms listed in the table. + * + *
| + * | Call from non-fork/join clients | + *Call from within fork/join computations | + *
| Arange async execution | + *{@link #execute(ForkJoinTask)} | + *{@link ForkJoinTask#fork} | + *
| Await and obtain result | + *{@link #invoke(ForkJoinTask)} | + *{@link ForkJoinTask#invoke} | + *
| Arrange exec and obtain Future | + *{@link #submit(ForkJoinTask)} | + *{@link ForkJoinTask#fork} (ForkJoinTasks are Futures) | + *
Sample Usage. Normally a single {@code ForkJoinPool} is * used for all parallel task execution in a program or subsystem. * Otherwise, use would not usually outweigh the construction and @@ -89,7 +109,8 @@ import java.util.concurrent.CountDownLat * {@code IllegalArgumentException}. * *
This implementation rejects submitted tasks (that is, by throwing
- * {@link RejectedExecutionException}) only when the pool is shut down.
+ * {@link RejectedExecutionException}) only when the pool is shut down
+ * or internal resources have been exhuasted.
*
* @since 1.7
* @author Doug Lea
@@ -116,21 +137,61 @@ public class ForkJoinPool extends Abstra
* of tasks profit from cache affinities, but others are harmed by
* 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:
+ *
+ * 1. 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.
+ *
+ * The ManagedBlocker extension API can't use option (1) so uses a
+ * special version of (2) in method awaitBlocker.
+ *
* The main throughput advantages of work-stealing stem from
* decentralized control -- workers mostly steal tasks from each
* other. We do not want to negate this by creating bottlenecks
- * implementing the management responsibilities of this class. So
- * we use a collection of techniques that avoid, reduce, or cope
- * well with contention. These entail several instances of
- * bit-packing into CASable fields to maintain only the minimally
- * required atomicity. To enable such packing, we restrict maximum
- * parallelism to (1<<15)-1 (enabling twice this to fit into a 16
- * bit field), which is far in excess of normal operating range.
- * Even though updates to some of these bookkeeping fields do
- * sometimes contend with each other, they don't normally
- * cache-contend with updates to others enough to warrant memory
- * padding or isolation. So they are all held as fields of
- * ForkJoinPool objects. The main capabilities are as follows:
+ * implementing other management responsibilities. So we use a
+ * collection of techniques that avoid, reduce, or cope well with
+ * contention. These entail several instances of bit-packing into
+ * CASable fields to maintain only the minimally required
+ * atomicity. To enable such packing, we restrict maximum
+ * parallelism to (1<<15)-1 (enabling twice this (to accommodate
+ * unbalanced increments and decrements) to fit into a 16 bit
+ * field, which is far in excess of normal operating range. Even
+ * though updates to some of these bookkeeping fields do sometimes
+ * contend with each other, they don't normally cache-contend with
+ * updates to others enough to warrant memory padding or
+ * isolation. So they are all held as fields of ForkJoinPool
+ * objects. The main capabilities are as follows:
*
* 1. Creating and removing workers. Workers are recorded in the
* "workers" array. This is an array as opposed to some other data
@@ -140,39 +201,25 @@ public class ForkJoinPool extends Abstra
* (workerLock) but the array is otherwise concurrently readable,
* and accessed directly by workers. To simplify index-based
* operations, the array size is always a power of two, and all
- * readers must tolerate null slots. Currently, all but the first
- * worker thread creation is on-demand, triggered by task
- * submissions, replacement of terminated workers, and/or
- * compensation for blocked workers. However, all other support
- * code is set up to work with other policies.
+ * readers must tolerate null slots. Currently, all worker thread
+ * creation is on-demand, triggered by task submissions,
+ * replacement of terminated workers, and/or compensation for
+ * blocked workers. However, all other support code is set up to
+ * work with other policies.
*
* 2. Bookkeeping for dynamically adding and removing workers. We
- * maintain a given level of parallelism (or, if
- * maintainsParallelism is false, at least avoid starvation). When
- * some workers are known to be blocked (on joins or via
+ * 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
* the total number. These two values are packed into one field,
* "workerCounts" because we need accurate snapshots when deciding
- * to create, resume or suspend. To support these decisions,
- * updates must be prospective (not retrospective). For example,
- * the running count is decremented before blocking by a thread
- * about to block, but incremented by the thread about to unblock
- * it. (In a few cases, these prospective updates may need to be
- * rolled back, for example when deciding to create a new worker
- * but the thread factory fails or returns null. In these cases,
- * we are no worse off wrt other decisions than we would be
- * otherwise.) Updates to the workerCounts field sometimes
- * transiently encounter a fair amount of contention when join
- * dependencies are such that many threads block or unblock at
- * about the same time. We alleviate this by sometimes bundling
- * updates (for example blocking one thread on join and resuming a
- * spare cancel each other out), and in most other cases
- * performing an alternative action (like releasing waiters and
- * finding spares; see below) as a more productive form of
- * backoff.
+ * to create, resume or suspend. Note however that the
+ * correspondance of these counts to reality is not guaranteed. In
+ * particular updates for unblocked threads may lag until they
+ * actually wake up.
*
* 3. Maintaining global run state. The run state of the pool
* consists of a runLevel (SHUTDOWN, TERMINATING, etc) similar to
@@ -221,7 +268,7 @@ public class ForkJoinPool extends Abstra
* 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
+ * 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.
* Conceptually they are merged into the same event, which is OK
@@ -230,76 +277,52 @@ public class ForkJoinPool extends Abstra
* 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 (see below). 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
+ * 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 preJoin and doBlock 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
+ * 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 preJoin and doBlock. We always need to create one
- * when the number of running threads becomes zero. But because
- * blocked joins are typically dependent, we don't necessarily
- * need or want one-to-one replacement. Using a one-to-one
- * compensation rule often leads to enough useless overhead
- * creating, suspending, resuming, and/or killing threads to
- * signficantly degrade throughput. We use a rule reflecting the
- * idea that, the more spare threads you already have, the more
- * evidence you need to create another one; where "evidence" is
- * expressed as the current deficit -- target minus running
- * threads. To reduce flickering and drift around target values,
- * the relation is quadratic: adding a spare if (dc*dc)>=(sc*pc)
- * (where dc is deficit, sc is number of spare threads and pc is
- * target parallelism.) This effectively reduces 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.
- *
- * 7. Maintaining other configuration parameters and monitoring
- * statistics. Updates to fields controlling parallelism level,
- * max size, etc can only meaningfully take effect for individual
- * threads upon their next top-level actions; i.e., between
- * stealing/running tasks/submission, which are separated by calls
- * to preStep. Memory ordering for these (assumed infrequent)
- * reconfiguration calls is ensured by using reads and writes to
- * volatile field workerCounts (that must be read in preStep anyway)
- * as "fences" -- user-level reads are preceded by reads of
- * workCounts, and writes are followed by no-op CAS to
- * workerCounts. The values reported by other management and
- * monitoring methods are either computed on demand, or are kept
- * in fields that are only updated when threads are otherwise
- * idle.
+ * 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.
*
* Beware that there is a lot of representation-level coupling
* among classes ForkJoinPool, ForkJoinWorkerThread, and
@@ -314,9 +337,9 @@ public class ForkJoinPool extends Abstra
* "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 a few
- * other coding oddities that help some methods perform reasonably
- * even when interpreted (not compiled).
+ * 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.
*
* The order of declarations in this file is: (1) statics (2)
* fields (along with constants used when unpacking some of them)
@@ -345,7 +368,7 @@ public class ForkJoinPool extends Abstra
* Default ForkJoinWorkerThreadFactory implementation; creates a
* new ForkJoinWorkerThread.
*/
- static class DefaultForkJoinWorkerThreadFactory
+ static class DefaultForkJoinWorkerThreadFactory
implements ForkJoinWorkerThreadFactory {
public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
return new ForkJoinWorkerThread(pool);
@@ -413,7 +436,7 @@ public class ForkJoinPool extends Abstra
/**
* Latch released upon termination.
*/
- private final CountDownLatch terminationLatch;
+ private final Phaser termination;
/**
* Creation factory for worker threads.
@@ -435,7 +458,7 @@ public class ForkJoinPool extends Abstra
private volatile long eventWaiters;
private static final int EVENT_COUNT_SHIFT = 32;
- private static final long WAITER_INDEX_MASK = (1L << EVENT_COUNT_SHIFT)-1L;
+ private static final long WAITER_ID_MASK = (1L << EVENT_COUNT_SHIFT)-1L;
/**
* A counter for events that may wake up worker threads:
@@ -484,74 +507,60 @@ public class ForkJoinPool extends Abstra
private static final int ONE_RUNNING = 1;
private static final int ONE_TOTAL = 1 << TOTAL_COUNT_SHIFT;
- /*
- * Fields parallelism. maxPoolSize, locallyFifo,
- * maintainsParallelism, and ueh are non-volatile, but external
- * reads/writes use workerCount fences to ensure visability.
- */
-
/**
* The target parallelism level.
+ * Accessed directly by ForkJoinWorkerThreads.
*/
- private int parallelism;
-
- /**
- * The maximum allowed pool size.
- */
- private int maxPoolSize;
+ final int parallelism;
/**
* True if use local fifo, not default lifo, for local polling
- * Replicated by ForkJoinWorkerThreads
+ * Read by, and replicated by ForkJoinWorkerThreads
*/
- private boolean locallyFifo;
+ final boolean locallyFifo;
/**
- * Controls whether to add spares to maintain parallelism
+ * The uncaught exception handler used when any worker abruptly
+ * terminates.
*/
- private boolean maintainsParallelism;
-
- /**
- * The uncaught exception handler used when any worker
- * abruptly terminates
- */
- private Thread.UncaughtExceptionHandler ueh;
+ private final Thread.UncaughtExceptionHandler ueh;
/**
* Pool number, just for assigning useful names to worker threads
*/
private final int poolNumber;
- // utilities for updating fields
+ // Utilities for CASing fields. Note that several of these
+ // are manually inlined by callers
/**
- * Adds delta to running count. Used mainly by ForkJoinTask.
- *
- * @param delta the number to add
+ * Increments running count. Also used by ForkJoinTask.
*/
- final void updateRunningCount(int delta) {
- int wc;
+ final void incrementRunningCount() {
+ int c;
do {} while (!UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc = workerCounts,
- wc + delta));
+ c = workerCounts,
+ c + ONE_RUNNING));
}
/**
- * Write fence for user modifications of pool parameters
- * (parallelism. etc). Note that it doesn't matter if CAS fails.
+ * Tries to decrement running count unless already zero
*/
- private void workerCountWriteFence() {
- int wc;
- UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc = workerCounts, wc);
+ final boolean tryDecrementRunningCount() {
+ int wc = workerCounts;
+ if ((wc & RUNNING_COUNT_MASK) == 0)
+ return false;
+ return UNSAFE.compareAndSwapInt(this, workerCountsOffset,
+ wc, wc - ONE_RUNNING);
}
/**
- * Read fence for external reads of pool parameters
- * (parallelism. maxPoolSize, etc).
+ * Tries to increment running count
*/
- private void workerCountReadFence() {
- int ignore = workerCounts;
+ final boolean tryIncrementRunningCount() {
+ int wc;
+ return UNSAFE.compareAndSwapInt(this, workerCountsOffset,
+ wc = workerCounts, wc + ONE_RUNNING);
}
/**
@@ -602,12 +611,12 @@ public class ForkJoinPool extends Abstra
lock.lock();
try {
ForkJoinWorkerThread[] ws = workers;
- int len = ws.length;
- if (k < 0 || k >= len || ws[k] != null) {
- for (k = 0; k < len && ws[k] != null; ++k)
+ int nws = ws.length;
+ if (k < 0 || k >= nws || ws[k] != null) {
+ for (k = 0; k < nws && ws[k] != null; ++k)
;
- if (k == len)
- ws = Arrays.copyOf(ws, len << 1);
+ if (k == nws)
+ ws = Arrays.copyOf(ws, nws << 1);
}
ws[k] = w;
workers = ws; // volatile array write ensures slot visibility
@@ -653,7 +662,7 @@ public class ForkJoinPool extends Abstra
return null;
}
}
- w.start(recordWorker(w), locallyFifo, ueh);
+ w.start(recordWorker(w), ueh);
return w;
}
@@ -661,24 +670,56 @@ public class ForkJoinPool extends Abstra
* Adjusts counts upon failure to create worker
*/
private void onWorkerCreationFailure() {
- int c;
- do {} while (!UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- c = workerCounts,
- c - (ONE_RUNNING|ONE_TOTAL)));
+ 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)))
+ break;
+ }
tryTerminate(false); // in case of failure during shutdown
}
/**
- * Create enough total workers to establish target parallelism,
- * giving up if terminating or addWorker fails
+ * 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
*/
- private void ensureEnoughTotalWorkers() {
- int wc;
- while (runState < TERMINATING &&
- ((wc = workerCounts) >>> TOTAL_COUNT_SHIFT) < parallelism) {
- if ((UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc + (ONE_RUNNING|ONE_TOTAL)) &&
- addWorker() == null))
+ private void ensureEnoughWorkers() {
+ for (;;) {
+ int pc = parallelism;
+ int wc = workerCounts;
+ int rc = wc & RUNNING_COUNT_MASK;
+ int tc = wc >>> TOTAL_COUNT_SHIFT;
+ if (tc < pc) {
+ if (runState == TERMINATING ||
+ (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 ||
+ runState == TERMINATING)
+ return;
+ if (w.tryResumeSpare())
+ incrementRunningCount();
+ break;
+ }
+ }
+ }
+ else
break;
}
}
@@ -698,67 +739,90 @@ public class ForkJoinPool extends Abstra
}
forgetWorker(w);
- // decrement total count, and if was running, running count
- int unit = w.isTrimmed()? ONE_TOTAL : (ONE_RUNNING|ONE_TOTAL);
- int wc;
- do {} while (!UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc = workerCounts, wc - unit));
+ // 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))
+ break;
+ }
accumulateStealCount(w); // collect final count
if (!tryTerminate(false))
- ensureEnoughTotalWorkers();
+ ensureEnoughWorkers();
}
// Waiting for and signalling events
/**
- * Ensures eventCount on exit is different (mod 2^32) than on
- * entry. CAS failures are OK -- any change in count suffices.
- */
- private void advanceEventCount() {
- int c;
- UNSAFE.compareAndSwapInt(this, eventCountOffset, c = eventCount, c+1);
- }
-
- /**
* Releases workers blocked on a count not equal to current count.
+ * @return true if any released
*/
- final void releaseWaiters() {
+ private void releaseWaiters() {
long top;
- int id;
- while ((id = (int)((top = eventWaiters) & WAITER_INDEX_MASK)) > 0 &&
- (int)(top >>> EVENT_COUNT_SHIFT) != eventCount) {
+ while ((top = eventWaiters) != 0L) {
ForkJoinWorkerThread[] ws = workers;
- ForkJoinWorkerThread w;
- if (ws.length >= id && (w = ws[id - 1]) != null &&
- UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
- top, w.nextWaiter))
- LockSupport.unpark(w);
+ 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;
+ }
+ else
+ break; // possibly stale; reread
+ }
}
}
/**
+ * Ensures eventCount on exit is different (mod 2^32) than on
+ * entry and wakes up all waiters
+ */
+ private void signalEvent() {
+ int c;
+ do {} while (!UNSAFE.compareAndSwapInt(this, eventCountOffset,
+ c = eventCount, c+1));
+ releaseWaiters();
+ }
+
+ /**
* Advances eventCount and releases waiters until interference by
* other releasing threads is detected.
*/
final void signalWork() {
- int ec;
- UNSAFE.compareAndSwapInt(this, eventCountOffset, ec=eventCount, ec+1);
- outer:for (;;) {
- long top = eventWaiters;
- ec = eventCount;
+ 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 (;;) {
- ForkJoinWorkerThread[] ws; ForkJoinWorkerThread w;
- int id = (int)(top & WAITER_INDEX_MASK);
- if (id <= 0 || (int)(top >>> EVENT_COUNT_SHIFT) == ec)
- return;
- if ((ws = workers).length < id || (w = ws[id - 1]) == null ||
- !UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
- top, top = w.nextWaiter))
- continue outer; // possibly stale; reread
- LockSupport.unpark(w);
- if (top != eventWaiters) // let someone else take over
+ 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
}
}
}
@@ -769,29 +833,39 @@ public class ForkJoinPool extends Abstra
* 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
*/
- private void eventSync(ForkJoinWorkerThread w) {
- if (!w.active) {
- int prev = w.lastEventCount;
- long nextTop = (((long)prev << EVENT_COUNT_SHIFT) |
+ 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_INDEX_MASK) == 0 ||
- (int)(top >>> EVENT_COUNT_SHIFT) == prev) &&
- eventCount == prev) {
+ (((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 == prev)
+ while (eventCount == wec)
w.doPark();
break;
}
}
- w.lastEventCount = eventCount;
+ wec = eventCount;
}
releaseWaiters();
+ int wc = workerCounts;
+ if ((wc & RUNNING_COUNT_MASK) <= parallelism) {
+ w.lastEventCount = wec;
+ return true;
+ }
+ if (wec != w.lastEventCount) // back up if may re-wait
+ w.lastEventCount = wec - (wc >>> TOTAL_COUNT_SHIFT);
+ return false;
}
/**
@@ -812,228 +886,219 @@ public class ForkJoinPool extends Abstra
* upon resume it rechecks to make sure that it is still needed.
*
* @param w the worker
- * @param worked false if the worker scanned for work but didn't
+ * @param retries the number of scans by caller failing to find work
* find any (in which case it may block waiting for work).
*/
- final void preStep(ForkJoinWorkerThread w, boolean worked) {
+ final void preStep(ForkJoinWorkerThread w, int retries) {
boolean active = w.active;
- boolean inactivate = !worked & active;
+ boolean inactivate = active && retries != 0;
for (;;) {
- if (inactivate) {
- int c = runState;
- if (UNSAFE.compareAndSwapInt(this, runStateOffset,
- c, c - ONE_ACTIVE))
- inactivate = active = w.active = false;
- }
- int wc = workerCounts;
- if ((wc & RUNNING_COUNT_MASK) <= parallelism) {
- if (!worked)
- eventSync(w);
- return;
+ int rs, wc;
+ if (inactivate &&
+ UNSAFE.compareAndSwapInt(this, runStateOffset,
+ rs = runState, rs - ONE_ACTIVE))
+ inactivate = active = w.active = false;
+ if (((wc = workerCounts) & RUNNING_COUNT_MASK) <= parallelism) {
+ if (active || eventSync(w, retries))
+ break;
}
- if (!(inactivate |= active) && // must inactivate to suspend
+ else if (!(inactivate |= active) && // must inactivate to suspend
UNSAFE.compareAndSwapInt(this, workerCountsOffset,
wc, wc - ONE_RUNNING) &&
- !w.suspendAsSpare()) // false if trimmed
- return;
+ !w.suspendAsSpare()) // false if trimmed
+ break;
}
}
/**
- * Adjusts counts and creates or resumes compensating threads for
- * a worker about to block on task joinMe, returning early if
- * joinMe becomes ready. First tries resuming an existing spare
- * (which usually also avoids any count adjustment), but must then
- * decrement running count to determine whether a new thread is
- * needed. See above for fuller explanation.
+ * 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.
+ *
+ * @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 void preJoin(ForkJoinTask joinMe) {
- boolean dec = false; // true when running count decremented
- for (;;) {
- releaseWaiters(); // help other threads progress
-
- if (joinMe.status < 0) // surround spare search with done checks
- return;
- ForkJoinWorkerThread spare = null;
- for (ForkJoinWorkerThread w : workers) {
- if (w != null && w.isSuspended()) {
- spare = w;
- break;
+ final boolean tryAwaitJoin(ForkJoinTask joinMe, int retries) {
+ if (joinMe.status < 0) // precheck to prime loop
+ 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
+ }
+ }
+ }
}
+ 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;
}
- if (joinMe.status < 0)
- return;
-
- if (spare != null && spare.tryUnsuspend()) {
- if (dec || joinMe.requestSignal() < 0) {
- int c;
- do {} while (!UNSAFE.compareAndSwapInt(this,
- workerCountsOffset,
- c = workerCounts,
- c + ONE_RUNNING));
- } // else no net count change
- LockSupport.unpark(spare);
- return;
- }
-
- int wc = workerCounts; // decrement running count
- if (!dec && (wc & RUNNING_COUNT_MASK) != 0 &&
- (dec = UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc -= ONE_RUNNING)) &&
- joinMe.requestSignal() < 0) { // cannot block
- int c; // back out
- do {} while (!UNSAFE.compareAndSwapInt(this,
- workerCountsOffset,
- c = workerCounts,
- c + ONE_RUNNING));
- return;
- }
-
- if (dec) {
- int tc = wc >>> TOTAL_COUNT_SHIFT;
- int pc = parallelism;
- int dc = pc - (wc & RUNNING_COUNT_MASK); // deficit count
- if ((dc < pc && (dc <= 0 || (dc * dc < (tc - pc) * pc) ||
- !maintainsParallelism)) ||
- tc >= maxPoolSize) // cannot add
- return;
- if (spare == null &&
- UNSAFE.compareAndSwapInt(this, workerCountsOffset, wc,
- wc + (ONE_RUNNING|ONE_TOTAL))) {
- addWorker();
- return;
+ 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
}
}
}
+ // 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 preJoin but with too many differing details to
- * integrate: There are no task-based signal counts, and only one
- * way to do the actual blocking. So for simplicity it is directly
- * incorporated into this method.
+ * 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.
*/
- final void doBlock(ManagedBlocker blocker, boolean maintainPar)
+ final void awaitBlocker(ManagedBlocker blocker)
throws InterruptedException {
- maintainPar &= maintainsParallelism; // override
- boolean dec = false;
- boolean done = false;
- for (;;) {
- releaseWaiters();
- if (done = blocker.isReleasable())
- break;
- ForkJoinWorkerThread spare = null;
- for (ForkJoinWorkerThread w : workers) {
- if (w != null && w.isSuspended()) {
- spare = w;
- break;
- }
- }
- if (done = blocker.isReleasable())
- break;
- if (spare != null && spare.tryUnsuspend()) {
- if (dec) {
- int c;
- do {} while (!UNSAFE.compareAndSwapInt(this,
- workerCountsOffset,
- c = workerCounts,
- c + ONE_RUNNING));
- }
- LockSupport.unpark(spare);
- break;
- }
+ boolean done;
+ if (done = blocker.isReleasable())
+ return;
+ int pc = parallelism;
+ int retries = 0;
+ boolean running = true; // false when running count decremented
+ outer:for (;;) {
int wc = workerCounts;
- if (!dec && (wc & RUNNING_COUNT_MASK) != 0)
- dec = UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc -= ONE_RUNNING);
- if (dec) {
- int tc = wc >>> TOTAL_COUNT_SHIFT;
- int pc = parallelism;
- int dc = pc - (wc & RUNNING_COUNT_MASK);
- if ((dc < pc && (dc <= 0 || (dc * dc < (tc - pc) * pc) ||
- !maintainPar)) ||
- tc >= maxPoolSize)
+ 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;
- if (spare == null &&
- UNSAFE.compareAndSwapInt(this, workerCountsOffset, wc,
- wc + (ONE_RUNNING|ONE_TOTAL))){
- addWorker();
+ }
+ 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;
+ }
}
+ Thread.yield();
}
}
-
+
try {
if (!done)
do {} while (!blocker.isReleasable() && !blocker.block());
} finally {
- if (dec) {
+ if (!running) {
int c;
- do {} while (!UNSAFE.compareAndSwapInt(this,
- workerCountsOffset,
- c = workerCounts,
- c + ONE_RUNNING));
- }
- }
- }
-
- /**
- * Unless there are not enough other running threads, adjusts
- * counts for a a worker in performing helpJoin that cannot find
- * any work, so that this worker can now block.
- *
- * @return true if worker may block
- */
- final boolean preBlockHelpingJoin(ForkJoinTask joinMe) {
- while (joinMe.status >= 0) {
- releaseWaiters(); // help other threads progress
-
- // if a spare exists, resume it to maintain parallelism level
- if ((workerCounts & RUNNING_COUNT_MASK) <= parallelism) {
- ForkJoinWorkerThread spare = null;
- for (ForkJoinWorkerThread w : workers) {
- if (w != null && w.isSuspended()) {
- spare = w;
- break;
- }
- }
- if (joinMe.status < 0)
- break;
- if (spare != null) {
- if (spare.tryUnsuspend()) {
- boolean canBlock = true;
- if (joinMe.requestSignal() < 0) {
- canBlock = false; // already done
- int c;
- do {} while (!UNSAFE.compareAndSwapInt
- (this, workerCountsOffset,
- c = workerCounts, c + ONE_RUNNING));
- }
- LockSupport.unpark(spare);
- return canBlock;
- }
- continue; // recheck -- another spare may exist
- }
- }
-
- int wc = workerCounts; // reread to shorten CAS window
- int rc = wc & RUNNING_COUNT_MASK;
- if (rc <= 2) // keep this and at most one other thread alive
- break;
-
- if (UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - ONE_RUNNING)) {
- if (joinMe.requestSignal() >= 0)
- return true;
- int c; // back out
do {} while (!UNSAFE.compareAndSwapInt
(this, workerCountsOffset,
c = workerCounts, c + ONE_RUNNING));
- break;
}
}
- return false;
- }
+ }
/**
* Possibly initiates and/or completes termination.
@@ -1056,7 +1121,7 @@ public class ForkJoinPool extends Abstra
// Finish now if all threads terminated; else in some subsequent call
if ((workerCounts >>> TOTAL_COUNT_SHIFT) == 0) {
advanceRunLevel(TERMINATED);
- terminationLatch.countDown();
+ termination.arrive();
}
return true;
}
@@ -1065,7 +1130,19 @@ public class ForkJoinPool extends Abstra
* Actions on transition to TERMINATING
*/
private void startTerminating() {
- // Clear out and cancel submissions, ignoring exceptions
+ for (int i = 0; i < 2; ++i) { // twice to mop up newly created workers
+ cancelSubmissions();
+ shutdownWorkers();
+ cancelWorkerTasks();
+ signalEvent();
+ interruptWorkers();
+ }
+ }
+
+ /**
+ * Clear out and cancel submissions, ignoring exceptions
+ */
+ private void cancelSubmissions() {
ForkJoinTask task;
while ((task = submissionQueue.poll()) != null) {
try {
@@ -1073,21 +1150,43 @@ public class ForkJoinPool extends Abstra
} catch (Throwable ignore) {
}
}
- // Propagate run level
- for (ForkJoinWorkerThread w : workers) {
+ }
+
+ /**
+ * 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(); // also resumes suspended workers
+ w.shutdown();
}
- // Ensure no straggling local tasks
- for (ForkJoinWorkerThread w : workers) {
+ }
+
+ /**
+ * 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();
}
- // Wake up idle workers
- advanceEventCount();
- releaseWaiters();
- // Unstick pending joins
- for (ForkJoinWorkerThread w : workers) {
+ }
+
+ /**
+ * 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();
@@ -1125,8 +1224,8 @@ public class ForkJoinPool extends Abstra
* active thread.
*/
final int idlePerActive() {
+ int pc = parallelism; // use parallelism, not rc
int ac = runState; // no mask -- artifically boosts during shutdown
- int pc = parallelism; // use targeted parallelism, not rc
// Use exact results for small values, saturate past 4
return pc <= ac? 0 : pc >>> 1 <= ac? 1 : pc >>> 2 <= ac? 3 : pc >>> 3;
}
@@ -1137,8 +1236,9 @@ public class ForkJoinPool extends Abstra
/**
* Creates a {@code ForkJoinPool} with parallelism equal to {@link
- * java.lang.Runtime#availableProcessors}, and using the {@linkplain
- * #defaultForkJoinWorkerThreadFactory default thread factory}.
+ * java.lang.Runtime#availableProcessors}, using the {@linkplain
+ * #defaultForkJoinWorkerThreadFactory default thread factory},
+ * no UncaughtExceptionHandler, and non-async LIFO processing mode.
*
* @throws SecurityException if a security manager exists and
* the caller is not permitted to modify threads
@@ -1147,13 +1247,14 @@ public class ForkJoinPool extends Abstra
*/
public ForkJoinPool() {
this(Runtime.getRuntime().availableProcessors(),
- defaultForkJoinWorkerThreadFactory);
+ defaultForkJoinWorkerThreadFactory, null, false);
}
/**
* Creates a {@code ForkJoinPool} with the indicated parallelism
- * level and using the {@linkplain
- * #defaultForkJoinWorkerThreadFactory default thread factory}.
+ * level, the {@linkplain
+ * #defaultForkJoinWorkerThreadFactory default thread factory},
+ * no UncaughtExceptionHandler, and non-async LIFO processing mode.
*
* @param parallelism the parallelism level
* @throws IllegalArgumentException if parallelism less than or
@@ -1164,31 +1265,25 @@ public class ForkJoinPool extends Abstra
* java.lang.RuntimePermission}{@code ("modifyThread")}
*/
public ForkJoinPool(int parallelism) {
- this(parallelism, defaultForkJoinWorkerThreadFactory);
- }
-
- /**
- * Creates a {@code ForkJoinPool} with parallelism equal to {@link
- * java.lang.Runtime#availableProcessors}, and using the given
- * thread factory.
- *
- * @param factory the factory for creating new threads
- * @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(ForkJoinWorkerThreadFactory factory) {
- this(Runtime.getRuntime().availableProcessors(), factory);
+ this(parallelism, defaultForkJoinWorkerThreadFactory, null, false);
}
/**
- * Creates a {@code ForkJoinPool} with the given parallelism and
- * thread factory.
+ * Creates a {@code ForkJoinPool} with the given parameters.
*
- * @param parallelism the parallelism level
- * @param factory the factory for creating new threads
+ * @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 If {@code maintainParallelism} is {@code true} and the pool
- * supports it ({@link #getMaintainsParallelism}), this method
- * attempts to maintain the pool's nominal parallelism. Otherwise
- * it activates a thread only if necessary to avoid complete
- * starvation. This option may be preferable when blockages use
- * timeouts, or are almost always brief.
+ * ensure sufficient parallelism while the current thread is blocked.
*
* If the caller is not a {@link ForkJoinTask}, this method is
* behaviorally equivalent to
@@ -1894,29 +1865,16 @@ public class ForkJoinPool extends Abstra
* first be expanded to ensure parallelism, and later adjusted.
*
* @param blocker the blocker
- * @param maintainParallelism if {@code true} and supported by
- * this pool, attempt to maintain the pool's nominal parallelism;
- * otherwise activate a thread only if necessary to avoid
- * complete starvation.
* @throws InterruptedException if blocker.block did so
*/
- public static void managedBlock(ManagedBlocker blocker,
- boolean maintainParallelism)
+ public static void managedBlock(ManagedBlocker blocker)
throws InterruptedException {
Thread t = Thread.currentThread();
if (t instanceof ForkJoinWorkerThread)
- ((ForkJoinWorkerThread) t).pool.
- doBlock(blocker, maintainParallelism);
- else
- awaitBlocker(blocker);
- }
-
- /**
- * Performs Non-FJ blocking
- */
- private static void awaitBlocker(ManagedBlocker blocker)
- throws InterruptedException {
- do {} while (!blocker.isReleasable() && !blocker.block());
+ ((ForkJoinWorkerThread) t).pool.awaitBlocker(blocker);
+ else {
+ do {} while (!blocker.isReleasable() && !blocker.block());
+ }
}
// AbstractExecutorService overrides. These rely on undocumented
@@ -1945,7 +1903,6 @@ public class ForkJoinPool extends Abstra
private static final long stealCountOffset =
objectFieldOffset("stealCount",ForkJoinPool.class);
-
private static long objectFieldOffset(String field, Class klazz) {
try {
return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
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.
* @throws IllegalArgumentException if parallelism less than or
* equal to zero, or greater than implementation limit
* @throws NullPointerException if the factory is null
@@ -1197,25 +1292,25 @@ public class ForkJoinPool extends Abstra
* because it does not hold {@link
* java.lang.RuntimePermission}{@code ("modifyThread")}
*/
- public ForkJoinPool(int parallelism, ForkJoinWorkerThreadFactory factory) {
+ public ForkJoinPool(int parallelism,
+ ForkJoinWorkerThreadFactory factory,
+ Thread.UncaughtExceptionHandler handler,
+ boolean asyncMode) {
checkPermission();
if (factory == null)
throw new NullPointerException();
if (parallelism <= 0 || parallelism > MAX_THREADS)
throw new IllegalArgumentException();
- this.poolNumber = poolNumberGenerator.incrementAndGet();
- int arraySize = initialArraySizeFor(parallelism);
this.parallelism = parallelism;
this.factory = factory;
- this.maxPoolSize = MAX_THREADS;
- this.maintainsParallelism = true;
+ this.ueh = handler;
+ this.locallyFifo = asyncMode;
+ int arraySize = initialArraySizeFor(parallelism);
this.workers = new ForkJoinWorkerThread[arraySize];
this.submissionQueue = new LinkedTransferQueue