$(SolutionPath) NewCachedThreadPool ()与 Executors.newFixedThreadPool ()

我认为文档很好地解释了这两种功能的区别和用法:

newFixedThreadPool

$(SystemRoot)

创建一个线程池，该线程池重用 固定数量的线程运行关闭 共享的无限制队列 $(TargetExt) 点，最多 nThreads 线程将 $(TargetFramework 版本) 主动处理任务 $(TargetName) 时提交附加任务 $(TargetPlatformMinVersion) 所有线程都是活动的，它们将等待 $(TargetPlatformVersion) 在队列中，直到线程 可用。如果有任何线程终止 $(TargetPlatformWinMDLocation) $(TargetUniversalCRTVersion) 由于执行过程中的失败 $(TEMP) 在关闭之前，一个新的将采取 $(TMP) 它的位置，如果需要执行 中的线程 $(ToolsetPropsfound) 池将一直存在，直到它被显式地 $(ToolsetTargetsfound) $(UCRTContentRoot) 关闭。

newCachedThreadPool

$(UniversalCRT _ IncludePath)

创建一个线程池，该线程池创建新的 $(UniversalCRT _ LibraryPath _ arm) $(UniversalCRT _ LibraryPath _ arm64) $(UniversalCRT _ LibraryPath _ x64) $(UniversalCRT _ LibraryPath _ x86) 线程，但将重用 $(UniversalCRT _ PropsPath) 以前构造的线程时 $(UniversalCRT _ SourcePath) 这些泳池可供使用 $(UniversalCRTSdkDir) 典型地改善... 的性能 $(UniversalCRTSdkDir _ 10) 执行许多短命程序的程序 $(UseDebugLibrary) 异步任务 $(UseLegacyManagedDebugger) 将重复使用以前建造的 $(UseOfATL) 线程如果可用。如果没有现有的 $(UseOfMfc) 线程可用时，新线程将 $(用户域) 创建并添加到池中。 $(USERDOMAIN _ ROAMINGPROFILE) $(用户名) 未使用的线程 60秒结束 $(用户资料) $(UserRootDir) 从缓存中移除。因此，一个池 闲置了足够长的时间 $(VBOX _ MSI _ INSTALL _ PATH) $(VC _ ATLMFC _ IncludePath) 不消耗任何资源。请注意 $(VC _ ATLMFC _ SourcePath) 具有类似性质但 $(VC _ CRT _ SourcePath) 不同的细节(例如: $(VC _ ExecutablePath _ ARM) 超时参数) $(VC _ ExecutablePath _ ARM64) 使用 ThreadPoolExecator 构造函数。

在资源方面，newFixedThreadPool将保持所有线程运行，直到它们被显式终止。在 newCachedThreadPool中，60秒内未使用的线程将被终止并从缓存中删除。

在这种情况下，资源消耗将在很大程度上取决于。例如，如果您有大量长时间运行的任务，我建议使用 FixedThreadPool。至于 CachedThreadPool，文档说“这些池通常会提高执行许多短期异步任务的程序的性能”。

你必须使用 newcachedThreadPool 只有当你有短期的异步任务时，如果你提交的任务需要更长的时间来处理，你会创建太多的线程。 Javadoc。如果以更快的速度向 newCachedThreadPool (http://rashcoder.com/be-careful-while-using-executors-newcachedthreadpool/)提交长时间运行的任务，则 CPU 可能达到100% 。

没错，对于服务于多个客户端和并发请求的服务器代码来说，Executors.newCachedThreadPool()不是一个很好的选择。

为什么? 它基本上有两个(相关的)问题:

$(VC _ ExecutablePath _ x86) $(VC _ ExecutablePath _ x86 _ ARM)

1. 它是无限的，这意味着您正在为任何人打开大门，通过简单地向服务注入更多的工作(DoS 攻击)来削弱您的 JVM。线程消耗的内存量不容忽视，而且基于它们正在进行的工作，还会增加内存消耗，因此这样很容易就会推翻服务器(除非您有其他断路器)。

$(VC _ ExecutablePath _ x86 _ ARM64) $(VC _ ExecutablePath _ x86 _ x64)

2. 无界问题因为 Execector 前面有一个 SynchronousQueue而变得更加严重，这意味着在任务提供者和线程池之间有一个直接的切换。如果所有现有线程都忙，则每个新任务将创建一个新线程。对于服务器代码来说，这通常是一个糟糕的策略。当 CPU 饱和时，现有的任务需要更长的时间才能完成。然而，提交的任务越来越多，创建的线程也越来越多，因此完成任务的时间越来越长。当 CPU 饱和时，更多的线程肯定不是服务器所需要的。

以下是我的建议:

使用固定大小的线程池 Executors.newFixedThreadPool或具有设定最大线程数的 线程池执行器。;

如果您看到 grepcode 中的代码，您将看到，它们正在内部调用 线程池执行器。并设置其属性。您可以创建一个来更好地控制您的需求。

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}


public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}

如果不担心 可调用/可运行任务的无限队列，可以使用其中之一。正如布鲁诺所建议的那样，相对于这两个，我也更喜欢 newFixedThreadPool而不是 newCachedThreadPool。

但与 newFixedThreadPool或 newCachedThreadPool相比，线程池执行器提供了更灵活的特性

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
RejectedExecutionHandler handler)

优点:

$(VC _ LibraryPath _ ATL _ x86) $(VC _ LibraryPath _ VC _ ARM)

1. 你可以完全控制 BlockingQueue的大小。它不是无界的，不像前两个选项。我不会得到一个内存不足的错误，由于一个悬而未决的可调用/可运行任务的巨大堆积，当有意外的动荡在系统中。

$(VC _ LibraryPath _ VC _ ARM _ Desktop) $(VC _ LibraryPath _ VC _ ARM _ OneCore)

2. 您可以实现自定义 拒收处理策略或使用其中一个策略:

   $(VC _ LibraryPath _ VC _ ARM _ Store)

   1. 在默认 ThreadPoolExecutor.AbortPolicy中，处理程序在拒绝时抛出运行时 RejectedExectionException。

   $(VC _ LibraryPath _ VC _ ARM64)

   2. 在 ThreadPoolExecutor.CallerRunsPolicy中，调用 execute 本身的线程运行任务。这提供了一个简单的反馈控制机制，可以减慢新任务的提交速度。

   $(VC _ LibraryPath _ VC _ ARM64 _ Desktop)

   3. 在 ThreadPoolExecutor.DiscardPolicy中，不能执行的任务被简单地删除。

   $(VC _ LibraryPath _ VC _ ARM64 _ OneCore) $(VC _ LibraryPath _ VC _ ARM64 _ Store)

   4. 在 ThreadPoolExecutor.DiscardOldestPolicy中，如果执行器没有关闭，那么将删除工作队列前端的任务，然后重试执行(这可能会再次失败，从而导致重复执行)

$(VC _ LibraryPath _ VC _ x64)

3. 您可以为以下用例实现一个自定义线程工厂:

   $(VC _ LibraryPath _ VC _ x64 _ Desktop)
   1. 设置更具描述性的线程名
   $(VC _ LibraryPath _ VC _ x64 _ OneCore)
   2. 设置线程守护进程状态
   $(VC _ LibraryPath _ VC _ x64 _ Store)
   3. 设置线程优先级

为了完成其他的回答，我想引用 Joshua Bloch 的有效 Java 第二版，第10章，第68条:

$(VC _ LibraryPath _ VC _ x86 _ Desktop) $(VC _ LibraryPath _ VC _ x86 _ OneCore) $(VC _ LibraryPath _ VC _ x86 _ Store) $(VC _ LibraryPath _ x64) $(VC _ LibraryPath _ x86) $(VC _ PGO _ RunTime _ Dir) $(VC _ ReferencesPath _ ARM)

”为特定应用程序选择执行者服务可能很棘手。如果您正在编写 小程序或 负载较轻的服务器，使用 执行程序 new-CachedThreadPool 是通常是 不错的选择，因为它不需要配置，而且通常“做正确的事情”但是对于 重载生产服务器来说，缓存的线程池是 不是个好选择！

$(VC _ ReferencesPath _ ARM64) $(VC _ ReferencesPath _ ATL _ ARM) $(VC _ ReferencesPath _ ATL _ ARM64) $(VC _ ReferencesPath _ ATL _ x64)

在 缓存线程池中，提交的任务不排队会立即移交给线程执行。如果没有可用的线程，则创建一个新线程.如果服务器负载过重，以至于它的所有 CPU 都被充分利用，并且有更多的任务到达，那么就会创建更多的线程，这只会使情况变得更糟。

$(VC _ ReferencesPath _ ATL _ x86) $(VC _ ReferencesPath _ VC _ ARM) $(VC _ ReferencesPath _ VC _ ARM64) $(VC _ ReferencesPath _ VC _ x64)

因此，对于 在重负载的生产服务器中，您最好使用 Executors.newFixedThreadPool，它为您提供一个具有固定数量线程的池，或者直接使用 ThreadPoolExecator 类 为了最大限度的控制。

我做了一些快速测试，结果如下:

1)如果使用 SynchronousQueue:

当线程达到最大大小后，任何新的工作都将被拒绝，例如下面的异常。

$(VC _ ReferencesPath _ x86) $(VC _ SourcePath)

在线程“ main”java.util.current 中出现异常。RejectedExectionException: 任务 java.util.while。FutureTask@3fe733d 被 java.util.concur.拒绝。ThreadPoolExecator@5acf9800[运行中，池大小 = 3，活动线程 = 3，排队任务 = 0，完成任务 = 0]

执行(ThreadPoolExecutor.java: 2047)

2)如果使用 LinkedBlockingQueue:

线程从不从最小大小增加到最大大小，这意味着线程池的大小是固定的。

ThreadPoolExecutor类是从许多 Executors工厂方法返回的执行器的基本实现。因此，让我们从 ThreadPoolExecutor的角度来研究 修好了和 缓存线程池。

线程池执行器

这个类的 主要建筑工程承建商是这样的:

public ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler
)

核心池面积

corePoolSize确定目标线程池的最小大小。即使没有要执行的任务，实现也会维护一个这样大小的池。

+-----------+-----------+-------------------+---------------------------------+
| Pool Type | Core Size |    Maximum Size   |         Queuing Strategy        |
+-----------+-----------+-------------------+---------------------------------+
|   Fixed   | n (fixed) |     n (fixed)     | Unbounded `LinkedBlockingQueue` |
+-----------+-----------+-------------------+---------------------------------+
|   Cached  |     0     | Integer.MAX_VALUE |        `SynchronousQueue`       |
+-----------+-----------+-------------------+---------------------------------+

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}