jdk-sandbox: comparison jdk/src/java.base/share/classes/java/util/concurrent/ThreadPoolExecutor.java

equal deleted inserted replaced

-:75c0f4d0ebea
+:d564ef4bed8f
 *
 * <dl>
 *
 * <dt>Core and maximum pool sizes</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>A {@code ThreadPoolExecutor} will automatically adjust the
-* A {@code ThreadPoolExecutor} will automatically adjust the
 * pool size (see {@link #getPoolSize})
 * according to the bounds set by
 * corePoolSize (see {@link #getCorePoolSize}) and
 * maximumPoolSize (see {@link #getMaximumPoolSize}).
 *
 * When a new task is submitted in method {@link #execute(Runnable)},
-* and fewer than corePoolSize threads are running, a new thread is
+* if fewer than corePoolSize threads are running, a new thread is
 * created to handle the request, even if other worker threads are
-* idle.  If there are more than corePoolSize but less than
+* idle.  Else if fewer than maximumPoolSize threads are running, a
-* maximumPoolSize threads running, a new thread will be created only
+* new thread will be created to handle the request only if the queue
-* if the queue is full.  By setting corePoolSize and maximumPoolSize
+* is full.  By setting corePoolSize and maximumPoolSize the same, you
-* the same, you create a fixed-size thread pool. By setting
+* create a fixed-size thread pool. By setting maximumPoolSize to an
-* maximumPoolSize to an essentially unbounded value such as {@code
+* essentially unbounded value such as {@code Integer.MAX_VALUE}, you
-* Integer.MAX_VALUE}, you allow the pool to accommodate an arbitrary
+* allow the pool to accommodate an arbitrary number of concurrent
-* number of concurrent tasks. Most typically, core and maximum pool
+* tasks. Most typically, core and maximum pool sizes are set only
-* sizes are set only upon construction, but they may also be changed
+* upon construction, but they may also be changed dynamically using
-* dynamically using {@link #setCorePoolSize} and {@link
+* {@link #setCorePoolSize} and {@link #setMaximumPoolSize}. </dd>
-* #setMaximumPoolSize}. </dd>
 *
 * <dt>On-demand construction</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>By default, even core threads are initially created and
-* By default, even core threads are initially created and
 * started only when new tasks arrive, but this can be overridden
 * dynamically using method {@link #prestartCoreThread} or {@link
 * #prestartAllCoreThreads}.  You probably want to prestart threads if
 * you construct the pool with a non-empty queue. </dd>
 *
 * <dt>Creating new threads</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>New threads are created using a {@link ThreadFactory}.  If not
-* New threads are created using a {@link ThreadFactory}.  If not
 * otherwise specified, a {@link Executors#defaultThreadFactory} is
 * used, that creates threads to all be in the same {@link
 * ThreadGroup} and with the same {@code NORM_PRIORITY} priority and
 * non-daemon status. By supplying a different ThreadFactory, you can
 * alter the thread's name, thread group, priority, daemon status,
 * take effect in a timely manner, and a shutdown pool may remain in a
 * state in which termination is possible but not completed.</dd>
 *
 * <dt>Keep-alive times</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>If the pool currently has more than corePoolSize threads,
-* If the pool currently has more than corePoolSize threads,
 * excess threads will be terminated if they have been idle for more
 * than the keepAliveTime (see {@link #getKeepAliveTime(TimeUnit)}).
 * This provides a means of reducing resource consumption when the
 * pool is not being actively used. If the pool becomes more active
 * later, new threads will be constructed. This parameter can also be
 * apply this time-out policy to core threads as well, so long as the
 * keepAliveTime value is non-zero. </dd>
 *
 * <dt>Queuing</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>Any {@link BlockingQueue} may be used to transfer and hold
-* Any {@link BlockingQueue} may be used to transfer and hold
 * submitted tasks.  The use of this queue interacts with pool sizing:
 *
 * <ul>
 *
 * <li>If fewer than corePoolSize threads are running, the Executor
 *
 * </dd>
 *
 * <dt>Rejected tasks</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>New tasks submitted in method {@link #execute(Runnable)} will be
-* New tasks submitted in method {@link #execute(Runnable)} will be
 * <em>rejected</em> when the Executor has been shut down, and also when
 * the Executor uses finite bounds for both maximum threads and work queue
 * capacity, and is saturated.  In either case, the {@code execute} method
 * invokes the {@link
 * RejectedExecutionHandler#rejectedExecution(Runnable, ThreadPoolExecutor)}
 * method of its {@link RejectedExecutionHandler}.  Four predefined handler
 * policies are provided:
 *
 * <ol>
 *
-* <li>In the default {@link ThreadPoolExecutor.AbortPolicy}, the
+* <li>In the default {@link ThreadPoolExecutor.AbortPolicy}, the handler
-* handler throws a runtime {@link RejectedExecutionException} upon
+* throws a runtime {@link RejectedExecutionException} upon rejection.
-* rejection.
 *
 * <li>In {@link ThreadPoolExecutor.CallerRunsPolicy}, the thread
 * that invokes {@code execute} itself runs the task. This provides a
 * simple feedback control mechanism that will slow down the rate that
 * new tasks are submitted.
 * especially when policies are designed to work only under particular
 * capacity or queuing policies. </dd>
 *
 * <dt>Hook methods</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>This class provides {@code protected} overridable
-* This class provides {@code protected} overridable
 * {@link #beforeExecute(Thread, Runnable)} and
 * {@link #afterExecute(Runnable, Throwable)} methods that are called
 * before and after execution of each task.  These can be used to
 * manipulate the execution environment; for example, reinitializing
 * ThreadLocals, gathering statistics, or adding log entries.
 * internal worker threads may in turn fail, abruptly terminate, and
 * possibly be replaced.</dd>
 *
 * <dt>Queue maintenance</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>Method {@link #getQueue()} allows access to the work queue
-* Method {@link #getQueue()} allows access to the work queue
 * for purposes of monitoring and debugging.  Use of this method for
 * any other purpose is strongly discouraged.  Two supplied methods,
 * {@link #remove(Runnable)} and {@link #purge} are available to
 * assist in storage reclamation when large numbers of queued tasks
 * become cancelled.</dd>
 *
 * <dt>Finalization</dt>
 *
-* <dd style="font-family:'DejaVu Sans', Arial, Helvetica, sans-serif">
+* <dd>A pool that is no longer referenced in a program <em>AND</em>
-* A pool that is no longer referenced in a program <em>AND</em>
 * has no remaining threads will be {@code shutdown} automatically. If
 * you would like to ensure that unreferenced pools are reclaimed even
 * if users forget to call {@link #shutdown}, then you must arrange
 * that unused threads eventually die, by setting appropriate
 * keep-alive times, using a lower bound of zero core threads and/or
 * Performs any further cleanup following run state transition on
 * invocation of shutdown.  A no-op here, but used by
 * ScheduledThreadPoolExecutor to cancel delayed tasks.
 */
 void onShutdown() {
-}
-/**
-* State check needed by ScheduledThreadPoolExecutor to
-* enable running tasks during shutdown.
-*
-* @param shutdownOK true if should return true if SHUTDOWN
-*/
-final boolean isRunningOrShutdown(boolean shutdownOK) {
-int rs = runStateOf(ctl.get());
-return rs == RUNNING || (rs == SHUTDOWN && shutdownOK);
 }
 /**
 * Drains the task queue into a new list, normally using
 * drainTo. But if the queue is a DelayQueue or any other kind of
 // Public constructors and methods
 /**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
-* parameters and default thread factory and rejected execution handler.
+* parameters, the default thread factory and the default rejected
-* It may be more convenient to use one of the {@link Executors} factory
+* execution handler.
-* methods instead of this general purpose constructor.
+*
+* <p>It may be more convenient to use one of the {@link Executors}
+* factory methods instead of this general purpose constructor.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 Executors.defaultThreadFactory(), defaultHandler);
 }
 /**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
-* parameters and default rejected execution handler.
+* parameters and {@linkplain ThreadPoolExecutor.AbortPolicy
+* default rejected execution handler}.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 threadFactory, defaultHandler);
 }
 /**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
-* parameters and default thread factory.
+* parameters and
+* {@linkplain Executors#defaultThreadFactory default thread factory}.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 public boolean isShutdown() {
 return ! isRunning(ctl.get());
 }
+/** Used by ScheduledThreadPoolExecutor. */
+boolean isStopped() {
+return runStateAtLeast(ctl.get(), STOP);
+}
 /**
 * Returns true if this executor is in the process of terminating
 * after {@link #shutdown} or {@link #shutdownNow} but has not
 * completely terminated.  This method may be useful for
 * debugging. A return of {@code true} reported a sufficient
 }
 }
 /**
 * A handler for rejected tasks that throws a
-* {@code RejectedExecutionException}.
+* {@link RejectedExecutionException}.
+*
+* This is the default handler for {@link ThreadPoolExecutor} and
+* {@link ScheduledThreadPoolExecutor}.
 */
 public static class AbortPolicy implements RejectedExecutionHandler {
 /**
 * Creates an {@code AbortPolicy}.
 */

changeset 45936	d564ef4bed8f
parent 44534	a076dffbc2c1
child 46041	d8e68e273172