前言

本文隸屬于專欄《100個問題搞定Java并發》，該專欄為筆者原創，引用請注明來源，不足和錯誤之處請在評論區幫忙指出，謝謝！

本專欄目錄結構和參考文獻請見100個問題搞定Java并發

正文

類注釋

/*** Factory and utility methods for {@link Executor}, {@link* ExecutorService}, {@link ScheduledExecutorService}, {@link* ThreadFactory}, and {@link Callable} classes defined in this* package. This class supports the following kinds of methods:** <ul>* <li> Methods that create and return an {@link ExecutorService}* set up with commonly useful configuration settings.* <li> Methods that create and return a {@link ScheduledExecutorService}* set up with commonly useful configuration settings.* <li> Methods that create and return a "wrapped" ExecutorService, that* disables reconfiguration by making implementation-specific methods* inaccessible.* <li> Methods that create and return a {@link ThreadFactory}* that sets newly created threads to a known state.* <li> Methods that create and return a {@link Callable}* out of other closure-like forms, so they can be used* in execution methods requiring {@code Callable}.* </ul>** @since 1.5* @author Doug Lea*/ public class Executors {

當前包內定義的 Executor 、 ExecutorService 、 ScheduledExecutorService 、 ThreadFactory 和 Callable 類的工廠和實用程序方法。

此類支持以下類型的方法：

創建并返回使用常用配置設置的 ExecutorService 方法。

創建并返回使用常用配置設置設置的 ScheduledExecutorService 方法。

創建并返回“包裝的” ExecutorService ，該服務通過使特定于實現的方法不可訪問來禁用重新配置。

創建并返回將新創建的線程設置為已知狀態的 ThreadFactory 方法。

這些方法從其他類似閉包的表單中創建并返回 Callable 的方法，因此可以在需要可調用的執行方法中使用它們。

固定大小的線程池

/*** Creates a thread pool that reuses a fixed number of threads* operating off a shared unbounded queue. At any point, at most* {@code nThreads} threads will be active processing tasks.* If additional tasks are submitted when all threads are active,* they will wait in the queue until a thread is available.* If any thread terminates due to a failure during execution* prior to shutdown, a new one will take its place if needed to* execute subsequent tasks. The threads in the pool will exist* until it is explicitly {@link ExecutorService#shutdown shutdown}.** @param nThreads the number of threads in the pool* @return the newly created thread pool* @throws IllegalArgumentException if {@code nThreads <= 0}*/public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}

創建一個線程池，該線程池重用在共享無界隊列上運行固定數量的線程。

在任何時候，最多 N 個活躍線程正在處理任務。

如果在所有線程都處于活動狀態時提交其他任務，它們將在隊列中等待，直到有線程可用。

如果任何線程在關機之前的執行過程中由于故障而終止，那么如果需要執行后續任務，將使用一個新線程代替它。

池中的線程將一直存在，直到顯式關閉。

/*** Creates a thread pool that reuses a fixed number of threads* operating off a shared unbounded queue, using the provided* ThreadFactory to create new threads when needed. At any point,* at most {@code nThreads} threads will be active processing* tasks. If additional tasks are submitted when all threads are* active, they will wait in the queue until a thread is* available. If any thread terminates due to a failure during* execution prior to shutdown, a new one will take its place if* needed to execute subsequent tasks. The threads in the pool will* exist until it is explicitly {@link ExecutorService#shutdown* shutdown}.** @param nThreads the number of threads in the pool* @param threadFactory the factory to use when creating new threads* @return the newly created thread pool* @throws NullPointerException if threadFactory is null* @throws IllegalArgumentException if {@code nThreads <= 0}*/public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory);}

和上面的區別在于，可以在需要時使用提供的ThreadFactory創建新線程。

工作竊取線程池

/*** Creates a thread pool that maintains enough threads to support* the given parallelism level, and may use multiple queues to* reduce contention. The parallelism level corresponds to the* maximum number of threads actively engaged in, or available to* engage in, task processing. The actual number of threads may* grow and shrink dynamically. A work-stealing pool makes no* guarantees about the order in which submitted tasks are* executed.** @param parallelism the targeted parallelism level* @return the newly created thread pool* @throws IllegalArgumentException if {@code parallelism <= 0}* @since 1.8*/public static ExecutorService newWorkStealingPool(int parallelism) {return new ForkJoinPool(parallelism,ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);}

創建一個線程池，該線程池維護足夠多的線程以支持給定的并行級別，并且可以使用多個隊列來減少爭用。

并行級別對應于積極參與或可參與任務處理的最大線程數。

線程的實際數量可能會動態增長和收縮。

工作竊取池不保證提交任務的執行順序。

/*** Creates a work-stealing thread pool using all* {@link Runtime#availableProcessors available processors}* as its target parallelism level.* @return the newly created thread pool* @see #newWorkStealingPool(int)* @since 1.8*/public static ExecutorService newWorkStealingPool() {return new ForkJoinPool(Runtime.getRuntime().availableProcessors(),ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);}

使用所有可用的處理器作為其目標并行級別來創建工作線程池。

單個線程的線程池

/*** Creates an Executor that uses a single worker thread operating* off an unbounded queue. (Note however that if this single* thread terminates due to a failure during execution prior to* shutdown, a new one will take its place if needed to execute* 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 newFixedThreadPool(1)} the returned executor is* guaranteed not to be reconfigurable to use additional threads.** @return the newly created single-threaded Executor*/public static ExecutorService newSingleThreadExecutor() {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));}

創建一個執行器，該執行器使用在無界隊列上運行的單個工作線程。

但是請注意，如果此單個線程在關機之前的執行過程中由于故障而終止，則在需要執行后續任務時，將替換一個新線程。

任務保證按順序執行，并且在任何給定時間都不會有多個任務處于活動狀態。

與上面的 newFixedThreadPool 不同，返回的執行器保證不可重新配置以使用其他線程。

/*** Creates an Executor that uses a single worker thread operating* off an unbounded queue, and uses the provided ThreadFactory to* 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* threads** @return the newly created single-threaded Executor* @throws NullPointerException if threadFactory is null*/public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory));}

和上面的區別在于，可以在需要時使用提供的ThreadFactory創建新線程。

自適應調整、緩存無上限的線程池

/*** Creates a thread pool that creates new threads as needed, but* will reuse previously constructed threads when they are* available. These pools will typically improve the performance* of programs that execute many short-lived asynchronous tasks.* Calls to {@code execute} will reuse previously constructed* threads if available. If no existing thread is available, a new* thread will be created and added to the pool. Threads that have* not been used for sixty seconds are terminated and removed from* the cache. Thus, a pool that remains idle for long enough will* not consume any resources. Note that pools with similar* properties but different details (for example, timeout parameters)* may be created using {@link ThreadPoolExecutor} constructors.** @return the newly created thread pool*/public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());}

創建一個線程池，該線程池根據需要創建新線程，但在以前構造的線程可用時將重用這些線程。

這些池通常會提高執行許多短期異步任務的程序的性能。

調用execute將重用以前構造的線程（如果可用）。

如果沒有可用的現有線程，將創建一個新線程并將其添加到池中。

六十秒未使用的線程將被終止并從緩存中刪除。

因此，空閑時間足夠長的池不會消耗任何資源。

請注意，可以使用ThreadPoolExecutor構造函數創建具有類似屬性但詳細信息不同（例如超時參數）的池。

/*** 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) {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>(),threadFactory);}

和上面的區別在于，可以在需要時使用提供的ThreadFactory創建新線程。

單線程周期調度線程池

/*** Creates a single-threaded executor that can schedule commands* to run after a given delay, or to execute periodically.* (Note however that if this single* thread terminates due to a failure during execution prior to* shutdown, a new one will take its place if needed to execute* 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));}

創建單線程執行器，該執行器可以安排命令在給定延遲后運行，或定期執行。

但是請注意，如果此單個線程在關機之前的執行過程中由于故障而終止，則在需要執行后續任務時，將替換一個新線程。

任務保證按順序執行，并且在任何給定時間都不會有多個任務處于活動狀態。

與下面的 newScheduledThreadPool 不同，返回的執行器保證不可重新配置以使用其他線程。

/*** Creates a single-threaded executor that can schedule commands* to run after a given delay, or to execute periodically. (Note* however that if this single thread terminates due to a failure* during execution prior to shutdown, a new one will take its* place if needed to execute 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, threadFactory)}* the returned executor is guaranteed not to be reconfigurable to* use additional threads.* @param threadFactory the factory to use when creating new* threads* @return a newly created scheduled executor* @throws NullPointerException if threadFactory is null*/public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1, threadFactory));}

和上面的區別在于，可以在需要時使用提供的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* @throws IllegalArgumentException if {@code corePoolSize < 0}*/public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {return new ScheduledThreadPoolExecutor(corePoolSize);}

創建一個線程池，該線程池可以安排命令在給定延遲后運行，或定期執行。

參數： corePoolSize–池中要保留的線程數，即使它們處于空閑狀態

/*** 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* @param threadFactory the factory to use when the executor* creates a new thread* @return a 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) {return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);}

和上面的區別在于，可以在需要時使用提供的ThreadFactory創建新線程。

不可配置代理線程池

/*** Returns an object that delegates all defined {@link* ExecutorService} methods to the given executor, but not any* other methods that might otherwise be accessible using* casts. This provides a way to safely "freeze" configuration and* disallow tuning of a given concrete implementation.* @param executor the underlying implementation* @return an {@code ExecutorService} instance* @throws NullPointerException if executor null*/public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {if (executor == null)throw new NullPointerException();return new DelegatedExecutorService(executor);}

返回一個對象，該對象將所有已定義的ExecutorService方法委托給給定的執行器，但不委托任何其他可以使用強制轉換訪問的方法。

這提供了一種安全地“凍結”配置并禁止對給定具體實現進行調優的方法。

不可配置周期調度線程池

/*** Returns an object that delegates all defined {@link* ScheduledExecutorService} methods to the given executor, but* not any other methods that might otherwise be accessible using* casts. This provides a way to safely "freeze" configuration and* disallow tuning of a given concrete implementation.* @param executor the underlying implementation* @return a {@code ScheduledExecutorService} instance* @throws NullPointerException if executor null*/public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {if (executor == null)throw new NullPointerException();return new DelegatedScheduledExecutorService(executor);}

和上面的區別在于 針對的是 ScheduledExecutorService

默認線程工廠

/*** Returns a default thread factory used to create new threads.* This factory creates all new threads used by an Executor in the* same {@link ThreadGroup}. If there is a {@link* java.lang.SecurityManager}, it uses the group of {@link* System#getSecurityManager}, else the group of the thread* invoking this {@code defaultThreadFactory} method. Each new* thread is created as a non-daemon thread with priority set to* the smaller of {@code Thread.NORM_PRIORITY} and the maximum* priority permitted in the thread group. New threads have names* accessible via {@link Thread#getName} of* <em>pool-N-thread-M</em>, where <em>N</em> is the sequence* number of this factory, and <em>M</em> is the sequence number* of the thread created by this factory.* @return a thread factory*/public static ThreadFactory defaultThreadFactory() {return new DefaultThreadFactory();}

返回用于創建新線程的默認線程工廠。

此工廠在同一線程組中創建執行器使用的所有新線程。

如果存在SecurityManager，則使用System.getSecurityManager組，否則使用調用此defaultThreadFactory方法的線程組。

每個新線程被創建為非守護進程線程，優先級設置為thread.NORM_priority和線程組中允許的最大優先級中的較小者。

新線程的名稱可以通過pool-N-Thread-M的Thread.getName訪問，其中N是此工廠的序列號，M是此工廠創建的線程的序列號。

特權線程工廠

/*** Returns a thread factory used to create new threads that* have the same permissions as the current thread.* This factory creates threads with the same settings as {@link* Executors#defaultThreadFactory}, additionally setting the* AccessControlContext and contextClassLoader of new threads to* be the same as the thread invoking this* {@code privilegedThreadFactory} method. A new* {@code privilegedThreadFactory} can be created within an* {@link AccessController#doPrivileged AccessController.doPrivileged}* action setting the current thread's access control context to* create threads with the selected permission settings holding* within that action.** <p>Note that while tasks running within such threads will have* the same access control and class loader settings as the* current thread, they need not have the same {@link* java.lang.ThreadLocal} or {@link* java.lang.InheritableThreadLocal} values. If necessary,* particular values of thread locals can be set or reset before* any task runs in {@link ThreadPoolExecutor} subclasses using* {@link ThreadPoolExecutor#beforeExecute(Thread, Runnable)}.* Also, if it is necessary to initialize worker threads to have* the same InheritableThreadLocal settings as some other* designated thread, you can create a custom ThreadFactory in* which that thread waits for and services requests to create* others that will inherit its values.** @return a thread factory* @throws AccessControlException if the current access control* context does not have permission to both get and set context* class loader*/public static ThreadFactory privilegedThreadFactory() {return new PrivilegedThreadFactory();}

返回用于創建與當前線程具有相同權限的新線程的線程工廠。

此工廠使用與defaultThreadFactory相同的設置創建線程，另外將新線程的AccessControlContext和contextClassLoader設置為與調用此privilegedThreadFactory方法的線程相同。

可以在AccessController.doPrivileged操作中創建新的privilegedThreadFactory，該操作設置當前線程的訪問控制上下文，以創建在該操作中保留選定權限設置的線程。

請注意，雖然在此類線程中運行的任務將具有與當前線程相同的訪問控制和類加載器設置，但它們不需要具有相同的ThreadLocal或InheritableThreadLocal值。

如有必要，在ThreadPoolExecutor子類中運行任何任務之前，可以使用ThreadPoolExecutor.beforeExecute（thread，Runnable）設置或重置線程局部變量的特定值。

此外，如果需要初始化工作線程以使其具有與其他指定線程相同的InheritableThreadLocal設置，則可以創建一個自定義ThreadFactory，該線程在其中等待和服務請求創建將繼承其值的其他線程。

Callable

/*** Returns a {@link Callable} object that, when* called, runs the given task and returns the given result. This* can be useful when applying methods requiring a* {@code Callable} to an otherwise resultless action.* @param task the task to run* @param result the result to return* @param <T> the type of the result* @return a callable object* @throws NullPointerException if task null*/public static <T> Callable<T> callable(Runnable task, T result) {if (task == null)throw new NullPointerException();return new RunnableAdapter<T>(task, result);}

返回一個 Callable 對象，該對象在被調用時運行給定任務并返回給定結果。

這在將需要 Callable 的方法應用于其他無結果的操作時非常有用。

/*** Returns a {@link Callable} object that, when* called, runs the given task and returns {@code null}.* @param task the task to run* @return a callable object* @throws NullPointerException if task null*/public static Callable<Object> callable(Runnable task) {if (task == null)throw new NullPointerException();return new RunnableAdapter<Object>(task, null);}

返回一個 Callable 對象，該對象在被調用時運行給定任務并返回null。

/*** Returns a {@link Callable} object that, when* called, runs the given privileged action and returns its result.* @param action the privileged action to run* @return a callable object* @throws NullPointerException if action null*/public static Callable<Object> callable(final PrivilegedAction<?> action) {if (action == null)throw new NullPointerException();return new Callable<Object>() {public Object call() { return action.run(); }};}

返回一個 Callable 對象，該對象在被調用時運行給定的特權操作并返回其結果。

/*** Returns a {@link Callable} object that, when* called, runs the given privileged exception action and returns* its result.* @param action the privileged exception action to run* @return a callable object* @throws NullPointerException if action null*/public static Callable<Object> callable(final PrivilegedExceptionAction<?> action) {if (action == null)throw new NullPointerException();return new Callable<Object>() {public Object call() throws Exception { return action.run(); }};}

返回一個 Callable 對象，該對象在被調用時運行給定的特權異常操作并返回其結果。

/*** Returns a {@link Callable} object that will, when called,* execute the given {@code callable} under the current access* control context. This method should normally be invoked within* an {@link AccessController#doPrivileged AccessController.doPrivileged}* action to create callables that will, if possible, execute* under the selected permission settings holding within that* action; or if not possible, throw an associated {@link* AccessControlException}.* @param callable the underlying task* @param <T> the type of the callable's result* @return a callable object* @throws NullPointerException if callable null*/public static <T> Callable<T> privilegedCallable(Callable<T> callable) {if (callable == null)throw new NullPointerException();return new PrivilegedCallable<T>(callable);}

返回一個 Callable 對象，該對象在被調用時將在當前訪問控制上下文下執行給定的可調用對象。

此方法通常應在AccessController.doPrivileged操作中調用，以創建可調用項，

如果可能，可調用項將在該操作中保留的選定權限設置下執行；

或者，如果不可能，拋出關聯的AccessControlException。

/*** Returns a {@link Callable} object that will, when called,* execute the given {@code callable} under the current access* control context, with the current context class loader as the* context class loader. This method should normally be invoked* within an* {@link AccessController#doPrivileged AccessController.doPrivileged}* action to create callables that will, if possible, execute* under the selected permission settings holding within that* action; or if not possible, throw an associated {@link* AccessControlException}.** @param callable the underlying task* @param <T> the type of the callable's result* @return a callable object* @throws NullPointerException if callable null* @throws AccessControlException if the current access control* context does not have permission to both set and get context* class loader*/public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {if (callable == null)throw new NullPointerException();return new PrivilegedCallableUsingCurrentClassLoader<T>(callable);}

返回一個 Callable 對象，該對象在被調用時將在當前訪問控制上下文下執行給定的可調用對象，并將當前上下文類裝入器作為上下文類裝入器。

此方法通常應在AccessController.doPrivileged操作中調用，以創建可調用項，

如果可能，可調用項將在該操作中保留的選定權限設置下執行；

或者，如果不可能，拋出關聯的AccessControlException。

下面是支持上面 public 方法的非 public 方法

運行給定任務并返回給定結果的可調用類

/*** A callable that runs given task and returns given result*/static final class RunnableAdapter<T> implements Callable<T> {final Runnable task;final T result;RunnableAdapter(Runnable task, T result) {this.task = task;this.result = result;}public T call() {task.run();return result;}}

在已建立的訪問控制設置下運行的可調用類

/*** A callable that runs under established access control settings*/static final class PrivilegedCallable<T> implements Callable<T> {private final Callable<T> task;private final AccessControlContext acc;PrivilegedCallable(Callable<T> task) {this.task = task;this.acc = AccessController.getContext();}public T call() throws Exception {try {return AccessController.doPrivileged(new PrivilegedExceptionAction<T>() {public T run() throws Exception {return task.call();}}, acc);} catch (PrivilegedActionException e) {throw e.getException();}}}

在已建立的訪問控制設置和當前類加載器下運行的可調用類

/*** A callable that runs under established access control settings and* current ClassLoader*/static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {private final Callable<T> task;private final AccessControlContext acc;private final ClassLoader ccl;PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {SecurityManager sm = System.getSecurityManager();if (sm != null) {// Calls to getContextClassLoader from this class// never trigger a security check, but we check// whether our callers have this permission anyways.sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);// Whether setContextClassLoader turns out to be necessary// or not, we fail fast if permission is not available.sm.checkPermission(new RuntimePermission("setContextClassLoader"));}this.task = task;this.acc = AccessController.getContext();this.ccl = Thread.currentThread().getContextClassLoader();}public T call() throws Exception {try {return AccessController.doPrivileged(new PrivilegedExceptionAction<T>() {public T run() throws Exception {Thread t = Thread.currentThread();ClassLoader cl = t.getContextClassLoader();if (ccl == cl) {return task.call();} else {t.setContextClassLoader(ccl);try {return task.call();} finally {t.setContextClassLoader(cl);}}}}, acc);} catch (PrivilegedActionException e) {throw e.getException();}}}

默認的線程工廠

/*** The default thread factory*/static class DefaultThreadFactory implements ThreadFactory {private static final AtomicInteger poolNumber = new AtomicInteger(1);private final ThreadGroup group;private final AtomicInteger threadNumber = new AtomicInteger(1);private final String namePrefix;DefaultThreadFactory() {SecurityManager s = System.getSecurityManager();group = (s != null) ? s.getThreadGroup() :Thread.currentThread().getThreadGroup();namePrefix = "pool-" +poolNumber.getAndIncrement() +"-thread-";}public Thread newThread(Runnable r) {Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);if (t.isDaemon())t.setDaemon(false);if (t.getPriority() != Thread.NORM_PRIORITY)t.setPriority(Thread.NORM_PRIORITY);return t;}}

捕獲訪問控制上下文和類加載器的線程工廠

/*** Thread factory capturing access control context and class loader*/static class PrivilegedThreadFactory extends DefaultThreadFactory {private final AccessControlContext acc;private final ClassLoader ccl;PrivilegedThreadFactory() {super();SecurityManager sm = System.getSecurityManager();if (sm != null) {// Calls to getContextClassLoader from this class// never trigger a security check, but we check// whether our callers have this permission anyways.sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);// Fail fastsm.checkPermission(new RuntimePermission("setContextClassLoader"));}this.acc = AccessController.getContext();this.ccl = Thread.currentThread().getContextClassLoader();}public Thread newThread(final Runnable r) {return super.newThread(new Runnable() {public void run() {AccessController.doPrivileged(new PrivilegedAction<Void>() {public Void run() {Thread.currentThread().setContextClassLoader(ccl);r.run();return null;}}, acc);}});}}

僅公開ExecutorService實現的ExecutorService方法的包裝類

/*** A wrapper class that exposes only the ExecutorService methods* of an ExecutorService implementation.*/static class DelegatedExecutorService extends AbstractExecutorService {private final ExecutorService e;DelegatedExecutorService(ExecutorService executor) { e = executor; }public void execute(Runnable command) { e.execute(command); }public void shutdown() { e.shutdown(); }public List<Runnable> shutdownNow() { return e.shutdownNow(); }public boolean isShutdown() { return e.isShutdown(); }public boolean isTerminated() { return e.isTerminated(); }public boolean awaitTermination(long timeout, TimeUnit unit)throws InterruptedException {return e.awaitTermination(timeout, unit);}public Future<?> submit(Runnable task) {return e.submit(task);}public <T> Future<T> submit(Callable<T> task) {return e.submit(task);}public <T> Future<T> submit(Runnable task, T result) {return e.submit(task, result);}public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)throws InterruptedException {return e.invokeAll(tasks);}public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException {return e.invokeAll(tasks, timeout, unit);}public <T> T invokeAny(Collection<? extends Callable<T>> tasks)throws InterruptedException, ExecutionException {return e.invokeAny(tasks);}public <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException {return e.invokeAny(tasks, timeout, unit);}} static class FinalizableDelegatedExecutorServiceextends DelegatedExecutorService {FinalizableDelegatedExecutorService(ExecutorService executor) {super(executor);}protected void finalize() {super.shutdown();}}

僅公開ScheduledExecutorService實現的ScheduledExecutorService方法的包裝類

/*** A wrapper class that exposes only the ScheduledExecutorService* methods of a ScheduledExecutorService implementation.*/static class DelegatedScheduledExecutorServiceextends DelegatedExecutorServiceimplements ScheduledExecutorService {private final ScheduledExecutorService e;DelegatedScheduledExecutorService(ScheduledExecutorService executor) {super(executor);e = executor;}public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {return e.schedule(command, delay, unit);}public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {return e.schedule(callable, delay, unit);}public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {return e.scheduleAtFixedRate(command, initialDelay, period, unit);}public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {return e.scheduleWithFixedDelay(command, initialDelay, delay, unit);}} /** Cannot instantiate. */private Executors() {} }

總結

以上是生活随笔為你收集整理的Executors 源码解析（JDK8）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。