< prev index next >
src/java.base/share/classes/java/util/concurrent/ThreadPoolExecutor.java
Print this page
8234131: Miscellaneous changes imported from jsr166 CVS 2021-01
Reviewed-by: martin
*** 219,235 ****
* <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.
*
! * <li>In {@link ThreadPoolExecutor.DiscardPolicy}, a task that
! * cannot be executed is simply dropped.
*
* <li>In {@link ThreadPoolExecutor.DiscardOldestPolicy}, if the
* executor is not shut down, the task at the head of the work queue
* is dropped, and then execution is retried (which can fail again,
! * causing this to be repeated.)
*
* </ol>
*
* It is possible to define and use other kinds of {@link
* RejectedExecutionHandler} classes. Doing so requires some care
--- 219,240 ----
* <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.
*
! * <li>In {@link ThreadPoolExecutor.DiscardPolicy}, a task that cannot
! * be executed is simply dropped. This policy is designed only for
! * those rare cases in which task completion is never relied upon.
*
* <li>In {@link ThreadPoolExecutor.DiscardOldestPolicy}, if the
* executor is not shut down, the task at the head of the work queue
* is dropped, and then execution is retried (which can fail again,
! * causing this to be repeated.) This policy is rarely acceptable. In
! * nearly all cases, you should also cancel the task to cause an
! * exception in any component waiting for its completion, and/or log
! * the failure, as illustrated in {@link
! * ThreadPoolExecutor.DiscardOldestPolicy} documentation.
*
* </ol>
*
* It is possible to define and use other kinds of {@link
* RejectedExecutionHandler} classes. Doing so requires some care
*** 270,280 ****
* keep-alive times, using a lower bound of zero core threads and/or
* setting {@link #allowCoreThreadTimeOut(boolean)}. </dd>
*
* </dl>
*
! * <p><b>Extension example</b>. Most extensions of this class
* override one or more of the protected hook methods. For example,
* here is a subclass that adds a simple pause/resume feature:
*
* <pre> {@code
* class PausableThreadPoolExecutor extends ThreadPoolExecutor {
--- 275,285 ----
* keep-alive times, using a lower bound of zero core threads and/or
* setting {@link #allowCoreThreadTimeOut(boolean)}. </dd>
*
* </dl>
*
! * <p><b>Extension example.</b> Most extensions of this class
* override one or more of the protected hook methods. For example,
* here is a subclass that adds a simple pause/resume feature:
*
* <pre> {@code
* class PausableThreadPoolExecutor extends ThreadPoolExecutor {
*** 1147,1158 ****
// Public constructors and methods
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
! * parameters, the default thread factory and the default rejected
! * execution handler.
*
* <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
--- 1152,1165 ----
// Public constructors and methods
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
! * parameters, the
! * {@linkplain Executors#defaultThreadFactory default thread factory}
! * and the {@linkplain ThreadPoolExecutor.AbortPolicy
! * default rejected execution handler}.
*
* <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
*** 1182,1192 ****
Executors.defaultThreadFactory(), defaultHandler);
}
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
! * 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
--- 1189,1199 ----
Executors.defaultThreadFactory(), defaultHandler);
}
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
! * parameters and the {@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
*** 1218,1228 ****
threadFactory, defaultHandler);
}
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
! * 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
--- 1225,1235 ----
threadFactory, defaultHandler);
}
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
! * parameters and the
* {@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
*** 2079,2089 ****
}
/**
* A handler for rejected tasks that discards the oldest unhandled
* request and then retries {@code execute}, unless the executor
! * is shut down, in which case the task is discarded.
*/
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardOldestPolicy} for the given executor.
*/
--- 2086,2109 ----
}
/**
* A handler for rejected tasks that discards the oldest unhandled
* request and then retries {@code execute}, unless the executor
! * is shut down, in which case the task is discarded. This policy is
! * rarely useful in cases where other threads may be waiting for
! * tasks to terminate, or failures must be recorded. Instead consider
! * using a handler of the form:
! * <pre> {@code
! * new RejectedExecutionHandler() {
! * public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
! * Runnable dropped = e.getQueue().poll();
! * if (dropped instanceof Future<?>) {
! * ((Future<?>)dropped).cancel(false);
! * // also consider logging the failure
! * }
! * e.execute(r); // retry
! * }}}</pre>
*/
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardOldestPolicy} for the given executor.
*/
< prev index next >