线程池学习 ，Executor 与 ExecutorService 和 Executors的区分

Executor

Executor, ExecutorService, 和 Executors 最主要的区别是 Executor 是一个抽象层面的核心接口(大致代码如下)。

 public interface Executor {
    void execute(Runnable command);
}

ExecutorService

ExecutorService （也是接口）接口 对 Executor 接口进行了扩展，提供了返回 Future 对象，终止，关闭线程池等方法。当调用 shutDown 方法时，线程池会停止接受新的任务，但会完成正在 pending 中的任务。

public interface ExecutorService extends Executor {
    void shutdown();
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
}

Executors

Executors 是一个工具类，类似于 Collections。提供工厂方法来创建不同类型的线程池，比如 FixedThreadPool 或 CachedThreadPool。

Executors 部分代码：

public class Executors {
    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>());
        }
}

下面详细看一下三者的区别。

Executor vs ExecutorService vs Executors

正如上面所说，这三者均是 Executor 框架中的一部分。Java 开发者很有必要学习和理解他们，以便更高效的使用 Java 提供的不同类型的线程池。总结一下这三者间的区别，以便大家更好的理解：

Executor 和 ExecutorService 这两个接口主要的区别是：ExecutorService 接口继承了 Executor 接口，是 Executor 的子接口。

Executor 和 ExecutorService 第二个区别是：Executor 接口定义了 execute()方法用来接收一个Runnable接口的对象，而 ExecutorService 接口中的 submit()方法可以接受Runnable和Callable接口的对象。

Executor 和 ExecutorService 接口第三个区别是 Executor 中的 execute() 方法不返回任何结果，而 ExecutorService 中的 submit()方法可以通过一个 Future 对象返回运算结果。

Executor 和 ExecutorService 接口第四个区别是除了允许客户端提交一个任务，ExecutorService 还提供用来控制线程池的方法。比如：调用 shutDown() 方法终止线程池。
---------------------可以通过 《Java Concurrency in Practice》 一书了解更多关于关闭线程池和如何处理 pending 的任务的知识。

Executors 类提供工厂方法用来创建不同类型的线程池。比如: newSingleThreadExecutor() 创建一个只有一个线程的线程池，newFixedThreadPool(int numOfThreads)来创建固定线程数的线程池，newCachedThreadPool()可以根据需要创建新的线程，但如果已有线程是空闲的会重用已有线程。

总结

译者注
个人觉得，利用 Executors 类提供的工厂方法来创建一个线程池是很方便，但对于需要根据实际情况自定义线程池某些参数的场景，就不太适用了。

举个例子：
当线程池中的线程均处于工作状态，并且线程数已达线程池允许的最大线程数时，就会采取指定的饱和策略来处理新提交的任务。总共有四种策略：

AbortPolicy: 直接抛异常

CallerRunsPolicy: 用调用者的线程来运行任务

DiscardOldestPolicy: 丢弃线程队列里最近的一个任务，执行新提交的任务

DiscardPolicy 直接将新任务丢弃

如果使用 Executors 的工厂方法创建的线程池，那么饱和策略都是采用默认的 AbortPolicy，所以如果我们想当线程池已满的情况，使用调用者的线程来运行任务，就要自己创建线程池，指定想要的饱和策略，而不是使用 Executors 了。

所以我们可以根据需要创建 ThreadPoolExecutor(ExecutorService接口的实现类) 对象，自定义一些参数，而不是调用 Executors 的工厂方法创建。

当然，在使用 Spring 框架的项目中，也可以使用 Spring 提供的 ThreadPoolTaskExecutor 类来创建线程池。ThreadPoolTaskExecutor 与 ThreadPoolExecutor 类似，也提供了许多参数用来自定义线程池，比如：核心线程池大小，线程池最大数量，饱和策略，线程活动保持时间等等。
可以参考看看threadpooltaskexcutor的具体参数含义

ThreadPoolExecutor的重要参数   
1、corePoolSize：核心线程数
        * 核心线程会一直存活，及时没有任务需要执行
        * 当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理
        * 设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭	
2、maxPoolSize：最大线程数
	* 当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务
	* 当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常
	* 当核心线程数达到最大时，新任务会放在队列中排队等待执行
3、 keepAliveTime：线程空闲时间
	* 当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize
	* 如果allowCoreThreadTimeout=true，则会直到线程数量=0
4、TimeUnit：时间单位 TimeUnit.SECONDS
5、BlockingQueue<Runnable>：阻塞队列，允许最大等待数量
6、RejectedExecutionHandler：任务拒绝处理器
	* 两种情况会拒绝处理任务：
		- 当线程数已经达到maxPoolSize，切队列已满，会拒绝新任务
		- 当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务
	* 线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy，会抛出异常
	* ThreadPoolExecutor类有几个内部实现类来处理这类情况：
		- AbortPolicy 丢弃任务，抛运行时异常
		- CallerRunsPolicy 执行任务
		- DiscardPolicy 忽视，什么都不会发生
		- DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
	* 实现RejectedExecutionHandler接口，可自定义处理器

怎么去记忆这6个参数呢?从需求出发，线程 池被初始化的时候，要给定一个最少线程数量，即核心线程数；给定 最大线程数;线程的超时问题，需要处理，一般默认是false,不允许核心线程超时,直接使用就可以；最大线程数比核心线程数量多的部分，有个降低策略，即超时以后，就释放掉，就规定线程空闲时间,以及相关的时间单位;超过最大线程数以后，队列允许等待的最大容量，即阻塞队列;然后

public static void main(String[] args) {
        new ThreadPoolExecutor(
        1,
        Integer.MAX_VALUE,10, 
        TimeUnit.SECONDS,
        new ArrayBlockingQueue<Runnable>(3),
        Executors.defaultThreadFactory(),
        new ThreadPoolExecutor.DiscardPolicy());
    }

@Slf4j
@EnableAsync
@Configuration
@RequiredArgsConstructor
public class AsyncConfiguration implements AsyncConfigurer {

    private final TaskExecutionProperties taskExecutionProperties;


    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        final String threadNamePrefix = "taskExecutor-";

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程池大小 or 10
        executor.setCorePoolSize(taskExecutionProperties.getPool().getCoreSize());
        // 最大线程数 or 50
        executor.setMaxPoolSize(taskExecutionProperties.getPool().getMaxSize());
        // 队列容量 or 10
        executor.setQueueCapacity(taskExecutionProperties.getPool().getQueueCapacity());
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 线程名前缀
        executor.setThreadNamePrefix(threadNamePrefix);
        // 这个配置是为了graceful shutdown?
        executor.setWaitForTasksToCompleteOnShutdown(true);
//executor.setAllowCoreThreadTimeOut(false);
        executor.initialize();
        return executor;
    }
}

二、ThreadPoolExecutor执行顺序
线程池按以下行为执行任务
1. 当线程数小于核心线程数时，创建线程。
2. 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
3. 当线程数大于等于核心线程数，且任务队列已满
- 若线程数小于最大线程数，创建线程
- 若线程数等于最大线程数，抛出异常，拒绝任务

三、如何设置参数
1、默认值
* corePoolSize=1
* queueCapacity=Integer.MAX_VALUE
* maxPoolSize=Integer.MAX_VALUE
* keepAliveTime=60s
* allowCoreThreadTimeout=false
* rejectedExecutionHandler=AbortPolicy()

2、如何来设置
    * 需要根据几个值来决定
        - tasks ：每秒的任务数，假设为500~1000
        - taskcost：每个任务花费时间，假设为0.1s
        - responsetime：系统允许容忍的最大响应时间，假设为1s
    * 做几个计算
        - corePoolSize = 每秒需要多少个线程处理？ 
            * threadcount = tasks/(1/taskcost) =tasks*taskcout =  (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50
            * 根据8020原则，如果80%的每秒任务数小于800，那么corePoolSize设置为80即可
        - queueCapacity = (coreSizePool/taskcost)*responsetime
            * 计算可得 queueCapacity = 80/0.1*1 = 80。意思是队列里的线程可以等待1s，超过了的需要新开线程来执行
            * 切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时，不能新开线程来执行，响应时间会随之陡增。
        - maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)
            * 计算可得 maxPoolSize = (1000-80)/10 = 92
            * （最大任务数-队列容量）/每个线程每秒处理能力 = 最大线程数
        - rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理
        - keepAliveTime和allowCoreThreadTimeout采用默认通常能满足

3、 以上都是理想值，实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了，则需要通过升级硬件（呵呵）和优化代码，降低taskcost来处理。

设置。

如何设置参数

1、默认值

• corePoolSize=1

• queueCapacity=Integer.MAX_VALUE

• maxPoolSize=Integer.MAX_VALUE

• keepAliveTime=60s

• allowCoreThreadTimeout=false

• rejectedExecutionHandler=AbortPolicy()

2、如何来设置

• 需要根据几个值来决定

• tasks ：每秒的任务数，假设为500~1000

• taskcost：每个任务花费时间，假设为0.1s

• responsetime：系统允许容忍的最大响应时间，假设为1s

• 做几个计算

• corePoolSize = 每秒需要多少个线程处理？

• threadcount = tasks/(1/taskcost) =tasks*taskcout = (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50

• 根据8020原则，如果80%的每秒任务数小于800，那么corePoolSize设置为80即可

• queueCapacity = (coreSizePool/taskcost)*responsetime

• 计算可得 queueCapacity = 80/0.1*1 = 80。意思是队列里的线程可以等待1s，超过了的需要新开线程来执行

• 切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时，不能新开线程来执行，响应时间会随之陡增。

• maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)

• 计算可得 maxPoolSize = (1000-80)/10 = 92

• （最大任务数-队列容量）/每个线程每秒处理能力 = 最大线程数

• rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理

• keepAliveTime和allowCoreThreadTimeout采用默认通常能满足

3、 以上都是理想值，实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了，则需要通过升级硬件（呵呵）和优化代码，降低taskcost来处理。