TPE-ThreadPoolExecutor

TPE:

java.util.concurrent.ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          @NotNull TimeUnit unit,
                          @NotNull BlockingQueue<Runnable> workQueue,
                          @NotNull ThreadFactory threadFactory,
                          @NotNull RejectedExecutionHandler handler)
Creates a new ThreadPoolExecutor with the given initial parameters.
Parameters:
	corePoolSize - the number of threads to keep in the pool, even if they are idle, unless allowCoreThreadTimeOut is set
					在池中保持的线程数，即使它们是空闲的，除非设置了allowCoreThreadTimeOut
	maximumPoolSize - the maximum number of threads to allow in the pool
					在池中允许的最大线程数
	keepAliveTime - when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating.
					当线程数大于核心数时，这是多余空闲线程在终止前等待新任务的最大时间。
	unit - the time unit for the keepAliveTime argument
					时间单位的keepAliveTime参数
	workQueue - the queue to use for holding tasks before they are executed. This queue will hold only the Runnable tasks submitted by the execute method.
					队列用于在执行任务之前执行任务。此队列只保留执行方法提交的可运行任务。
	threadFactory - the factory to use when the executor creates a new thread
					在执行器创建新线程时使用的工厂
	handler - the handler to use when execution is blocked because the thread bounds and queue capacities are reached
					在执行被阻塞时使用的handler，因为到达了线程边界和队列容量
Throws:
	IllegalArgumentException - if one of the following holds:
		corePoolSize < 0
		keepAliveTime < 0
		maximumPoolSize <= 0
		maximumPoolSize < corePoolSize
	NullPointerException - if workQueue or threadFactory or handler is null

allowCoreThreadTimeOut -- If false (default), core threads stay alive even when idle. If true, core threads use keepAliveTime to time out waiting for work
如果false(默认)，核心线程即使在空闲时仍然存活。如果是true，核心线程使用keepAliveTime来等待工作
也就是说，如果allowCoreThreadTimeOut不改变(即：false), 则corePoolSize计数中的Thread即便是idle空闲的，也保持alive状态；
如果被设置成true了，此时keepAliveTime就派上用场了，

JDK:

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)
用给定的初始参数创建新的 ThreadPoolExecutor。
参数：
corePoolSize - 池中所保存的线程数，包括空闲线程。
maximumPoolSize - 池中允许的最大线程数。
keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime 参数的时间单位。
workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。
threadFactory - 执行程序创建新线程时使用的工厂。
handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
抛出：
IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小于 0，或者 maximumPoolSize 小于等于 0，或者 corePoolSize 大于 maximumPoolSize。
NullPointerException - 如果 workQueue、 threadFactory 或 handler 为 null。