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

equal deleted inserted replaced

-:a5a2e4770524
+:21efc1774302
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
 package java.util.concurrent;
+import static java.lang.ref.Reference.reachabilityFence;
 import java.security.AccessControlContext;
 import java.security.AccessControlException;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.security.PrivilegedActionException;
 * create a new thread when needed. Unlike the otherwise
 * equivalent {@code newFixedThreadPool(1, threadFactory)} the
 * returned executor is guaranteed not to be reconfigurable to use
 * additional threads.
 *
-* @param threadFactory the factory to use when creating new
+* @param threadFactory the factory to use when creating new threads
-* threads
-*
 * @return the newly created single-threaded Executor
 * @throws NullPointerException if threadFactory is null
 */
 public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
 return new FinalizableDelegatedExecutorService
 /**
 * Creates a thread pool that creates new threads as needed, but
 * will reuse previously constructed threads when they are
 * available, and uses the provided
 * ThreadFactory to create new threads when needed.
+*
 * @param threadFactory the factory to use when creating new threads
 * @return the newly created thread pool
 * @throws NullPointerException if threadFactory is null
 */
 public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
 * subsequent tasks.)  Tasks are guaranteed to execute
 * sequentially, and no more than one task will be active at any
 * given time. Unlike the otherwise equivalent
 * {@code newScheduledThreadPool(1)} the returned executor is
 * guaranteed not to be reconfigurable to use additional threads.
+*
 * @return the newly created scheduled executor
 */
 public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
 return new DelegatedScheduledExecutorService
 (new ScheduledThreadPoolExecutor(1));
 * guaranteed to execute sequentially, and no more than one task
 * will be active at any given time. Unlike the otherwise
 * equivalent {@code newScheduledThreadPool(1, threadFactory)}
 * the returned executor is guaranteed not to be reconfigurable to
 * use additional threads.
-* @param threadFactory the factory to use when creating new
+*
-* threads
+* @param threadFactory the factory to use when creating new threads
-* @return a newly created scheduled executor
+* @return the newly created scheduled executor
 * @throws NullPointerException if threadFactory is null
 */
 public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
 return new DelegatedScheduledExecutorService
 (new ScheduledThreadPoolExecutor(1, threadFactory));
 /**
 * Creates a thread pool that can schedule commands to run after a
 * given delay, or to execute periodically.
 * @param corePoolSize the number of threads to keep in the pool,
 * even if they are idle
-* @return a newly created scheduled thread pool
+* @return the newly created scheduled thread pool
 * @throws IllegalArgumentException if {@code corePoolSize < 0}
 */
 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
 return new ScheduledThreadPoolExecutor(corePoolSize);
 }
 * given delay, or to execute periodically.
 * @param corePoolSize the number of threads to keep in the pool,
 * even if they are idle
 * @param threadFactory the factory to use when the executor
 * creates a new thread
-* @return a newly created scheduled thread pool
+* @return the newly created scheduled thread pool
 * @throws IllegalArgumentException if {@code corePoolSize < 0}
 * @throws NullPointerException if threadFactory is null
 */
 public static ScheduledExecutorService newScheduledThreadPool(
 int corePoolSize, ThreadFactory threadFactory) {
 /**
 * A wrapper class that exposes only the ExecutorService methods
 * of an ExecutorService implementation.
 */
 private static class DelegatedExecutorService
-extends AbstractExecutorService {
+implements ExecutorService {
 private final ExecutorService e;
 DelegatedExecutorService(ExecutorService executor) { e = executor; }
-public void execute(Runnable command) { e.execute(command); }
+public void execute(Runnable command) {
+try {
+e.execute(command);
+} finally { reachabilityFence(this); }
+}
 public void shutdown() { e.shutdown(); }
-public List<Runnable> shutdownNow() { return e.shutdownNow(); }
+public List<Runnable> shutdownNow() {
-public boolean isShutdown() { return e.isShutdown(); }
+try {
-public boolean isTerminated() { return e.isTerminated(); }
+return e.shutdownNow();
+} finally { reachabilityFence(this); }
+}
+public boolean isShutdown() {
+try {
+return e.isShutdown();
+} finally { reachabilityFence(this); }
+}
+public boolean isTerminated() {
+try {
+return e.isTerminated();
+} finally { reachabilityFence(this); }
+}
 public boolean awaitTermination(long timeout, TimeUnit unit)
 throws InterruptedException {
-return e.awaitTermination(timeout, unit);
+try {
+return e.awaitTermination(timeout, unit);
+} finally { reachabilityFence(this); }
 }
 public Future<?> submit(Runnable task) {
-return e.submit(task);
+try {
+return e.submit(task);
+} finally { reachabilityFence(this); }
 }
 public <T> Future<T> submit(Callable<T> task) {
-return e.submit(task);
+try {
+return e.submit(task);
+} finally { reachabilityFence(this); }
 }
 public <T> Future<T> submit(Runnable task, T result) {
-return e.submit(task, result);
+try {
+return e.submit(task, result);
+} finally { reachabilityFence(this); }
 }
 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
 throws InterruptedException {
-return e.invokeAll(tasks);
+try {
+return e.invokeAll(tasks);
+} finally { reachabilityFence(this); }
 }
 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException {
-return e.invokeAll(tasks, timeout, unit);
+try {
+return e.invokeAll(tasks, timeout, unit);
+} finally { reachabilityFence(this); }
 }
 public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
 throws InterruptedException, ExecutionException {
-return e.invokeAny(tasks);
+try {
+return e.invokeAny(tasks);
+} finally { reachabilityFence(this); }
 }
 public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException, ExecutionException, TimeoutException {
-return e.invokeAny(tasks, timeout, unit);
+try {
+return e.invokeAny(tasks, timeout, unit);
+} finally { reachabilityFence(this); }
 }
 }
 private static class FinalizableDelegatedExecutorService
 extends DelegatedExecutorService {

changeset 48843	21efc1774302
parent 47306	90b7465b9ac7