一基础知识

1.1 线程池的优势

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务加入队列，然后在线程创建后启动这些任务，如果线程超过了最大数量，超出的数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。
他的主要特点为：线程复用；控制最大并发数；管理线程。

降低资源消耗，通过重复利用自己创建的线程降低线程创建和销毁造成的消耗。
提高响应速度，当任务到达时，任务可以不需要等到线程和粗昂就爱你就能立即执行。
提高线程的可管理性，线程是稀缺资源，如果无限的创建，不仅会消耗资源，还会降低系统的稳定性，使用线程池可以进行统一分配，调优和监控。

1.2 线程池的使用
Java中的线程池是通过Executor框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor这几个类。
Executors类的几个创建线程的方法
Executors.newScheduledThreadPool();
Executors.newWorkStealingPool(n)：java8新增，使用目前机器上可以的处理器作为他的并行级别
Executors.newFixedThreadPool(n)：创建有 n 个线程的线程池
Executors.newSingleThreadExecutor()：创建只有一个线程的线程池

Executors.newCachedThreadPool()：适用执行很多短期异步的小程序或者负载均衡或者负载较轻的服务器

public class MyThreadPoolDemo {
 public static void main(String[] args) {
     // 一池5个处理线程
     ExecutorService threadPool1 = Executors.newFixedThreadPool(5);
     // 一池只有一个线程
     ExecutorService threadPool2 = Executors.newSingleThreadExecutor();
     // 一池N个线程，不固定，按需
     ExecutorService threadPool3 = Executors.newCachedThreadPool();
     try {
         for (int i = 0; i < 10; i++) {
             threadPool3.execute(() -> {
                 System.out.println(Thread.currentThread().getName() + " 执行业务");
             });
             TimeUnit.MICROSECONDS.sleep(200);
         }
     } catch (Exception e) {
         e.printStackTrace();
     }finally {
         threadPool3.shutdown();
     }
 }
}

1.3 生命周期

线程池从诞生到死亡，中间会经历running、shutdown、stop、tidying、terminated五个生命周期状态。

RUNNING 表示线程池处于运行状态，能够接受新提交的任务且能对已添加的任务进行处理。RUNNING状态是线程池的初始化状态，线程池一旦被创建就处于RUNNING状态。
SHUTDOWN 线程处于关闭状态，不接受新任务，但可以处理已添加的任务。RUNNING状态的线程池调用shutdown方法后会进入SHUTDOWN状态。
STOP 线程池处于停止状态，不接收任务，不处理已添加的任务，且会中断正在执行任务的线程。RUNNING状态的线程池调用了 shutdownNow方法后会进入STOP状态。
TIDYING 当所有任务已终止，且任务数量为0时，线程池会进入TIDYING。当线程池处于SHUTDOWN状态时，阻塞队列中的任务被执行完了，且线程池中没有正在执行的任务了，状态会由SHUTDOWN变为TIDYING。当线程处于STOP状态时，线程池中没有正在执行的任务时则会由STOP变为TIDYING。
TERMINATED 线程终止状态。处于TIDYING状态的线程执行terminated()后进入TERMINATED状态。

1.4 七大参数

// JDK8源码：ThreadPoolExecutor
public class ThreadPoolExecutor extends AbstractExecutorService {
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
}

corePoolSize：线程池中的常驻核心线程数。在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近是理解为今日当值线程。当线程池中的线程数目达到corePoolSize后，就会把到达的任务放入到缓存队列当中。
maximumPoolSize：线程池能够容纳同时执行的最大线程数，此值大于等于1。
keepAliveTime：多余的空闲线程存活时间，当空间时间达到keepAliveTime值时，多余的线程会被销毁直到只剩下corePoolSize个线程为止。只有当线程池中的线程数大于corePoolSize时keepAliveTime才会起作用，直到线程池中的线程数不大于corepoolSIze。
unit：keepAliveTime的单位。
workQueue：任务阻塞队列，被提交但尚未被执行的任务。
threadFactory：表示生成线程池中工作线程的线程工厂，用户创建新线程，一般用默认即可。
handler：拒绝策略，表示当线程队列满了并且工作线程大于等于线程池的最大显示数(maxnumPoolSize)时如何来拒绝。参考

二工作机制

2.1 工作流程
线程池提交任务是从 executor 方法开始的：
在创建了线程池之后，等待提交过来的任务请求。
当调用execute()方法添加一个请求任务时，线程池会做出如下判断。
1. 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务如果正在运行的线程数量大于等于corePoolSize，那么就把这个任务放到队列里面。
2. 如果这时候队列满了，且正在运行的线程数量还小于maxnumPoolSize，那么还是需要创建非核心线程立刻运行这个任务。
3. 如果队列满了，且正在运行的线程大于等于maxnumPoolSize，那么线程池会启动饱和拒绝策略来执行。
当一个线程完成任务后，它会从队列中取出下一个任务来执行。
当一个线程无事可做超过一定时间（keepAliveTime）时，线程池会判断：如果当前运行的线程数大于corePoolSize，那么这个线程就会被停掉销毁。

2.2 拒绝策略
等待队列也已经排满了，再也塞不下新的任务了。同时，线程池的maxnumPoolSize也到达了，无法继续为新任务服务，这时我们需要拒绝策略机制合理的处理这个问题。JDK内置了4种拒绝策略。
在JDK中提供了RejectedExecutionHandler接口来执行拒绝操作。实现RejectedExecutionHandler的类有四个，对应了四种拒绝策略。
AbortPolicy(默认)：直接抛出RejectedException异常阻止系统正常运行
CallerRunPolicy：“调用者运行”一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。
DiscardPolicy：接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种拒绝策略方案。
三手写线程池
1）你在工作中单一的/固定数的/可变你的三种创建线程池的方法，你用哪个多？超级大坑！

答案是一个都不用，我们生产上只能使用自定义的线程池，也即手写线程池。

2）Executors中JDK给你提供了，为什么不用?

在《阿里巴巴Java开发手册》中提到：线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

Executors 返回的线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

CachedThreadPool 和 ScheduledThreadPool：允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

public class MyThreadPoolDemo {
public static void main(String[] args) {
   // 手写线程池
   ThreadPoolExecutor threadPool4 = new ThreadPoolExecutor(
           2, // 核心线程线
           5, // 最大线程数
           1L, // 多余线程存活时间
           TimeUnit.SECONDS, // 时间单位
           new LinkedBlockingDeque<>(3), // 阻塞队列，存放需要执行的任务
           Executors.defaultThreadFactory(), // 线程工厂
           new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
   );
   try {
       for (int i = 0; i < 10; i++) {
           threadPool4.execute(() -> {
               System.out.println(Thread.currentThread().getName() + " 执行业务");
           });
       }
   } catch (Exception e) {
       e.printStackTrace();
   }finally {
       threadPool4.shutdown();
   }
}
}

3.1 配置线程池参数

Runtime.getRuntime().availableProcessor()：获取CPU核数

1）CPU密集型
CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。CPU密集任务只有真正的多核CPU才可能得到加速（通过多线程方式）。如果是单核CPU，那么开几个模拟的多线程任务都不可能得到加速，因为CPU的运算能力就只有这点。
CPU密集型任务配置只可能少的线程数量：CPU核数+1个线程的线程池。

2）IO密集型
有两种方式：

CPU核数 * 2

CPU核数 /（1 - 阻塞系数），一般阻塞系数在0.8-0.9之间。

四 Spring与线程池

在SpringBoot中，可以使用 @EnableAsync，@Async 这两个注解搭配使用，这样可以快速使用线程池异步调用方法。

4.1 小案例

配置SpringBoot使用的自定义线程池

public class MyAsyncConfigurer implements AsyncConfigurer {
 /**
  * 返回一个线程池
  */
 @Override
 public Executor getAsyncExecutor() {
     ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
     executor.setCorePoolSize(5);
     executor.setMaxPoolSize(50);
     executor.setKeepAliveSeconds(60);
     executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
     executor.initialize();
     return executor;
 }
 /**
  * 在使用void返回类型的异步方法执行期间抛出异常时要使用的实例
  */
 @Override
 public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
     return new SimpleAsyncUncaughtExceptionHandler();
 }
}

调用异步方法
当在程序中定义了多个线程池时，@Async注解可以指定使用那个线程池，使用value属性指定线程池名

@Component
public class AsyncMethod {
 @Async
 public void fun1(String str) {
     System.out.println("I am another thread: " + str);
 }
}

4.2 Spring实现的线程池

SimpleAsyncTaskExecutor：如果没有自定义线程池，Spring默认使用这个。注意：这个类并不是一个真正的线程池，在它调用executor方法时，会创建一个线程来执行任务，但是并不是维护了一个线程池存储线程。
SyncTaskExecutor：这也不是一个线程池，而且是同步执行。
ConcurrentTaskExecutor：不推荐使用，只要当 ThreadPoolTaskExecutor 不满需求时，才考虑使用这个。
ThreadPoolTaskExecutor：最常推荐使用，本质是对 ThreadPoolExecutor 的封装。

在SpringBoot中配置多个线程池，@Async注解的value属性可以指定使用那一个线程。这样做的好处是：当项目中有多个逻辑需要使用到多线程，那么可以让不同的业务使用不同的线程池，防止一个线程池阻塞时，影响到其他的业务

@Configuration
public class ThreadPoolConfig {
    @Bean(value = "primaryExecutor")
    public Executor executor1() {
        return getExecutor(10, 60);
    }
    @Bean(value = "secondExecutor")
    public Executor executor2() {
        return getExecutor(5, 30);
    }
    private Executor getExecutor(int min, int max) {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(min);
        executor.setMaxPoolSize(max);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("apps-thread-");
        executor.initialize();
        return executor;
    }
}

4.3 @Async修饰的异步方法

被@Async修饰的方法有三种：

无返回值 void 类型的方法
返回值为：Future类型

返回值为：CompletableFuture类型

五源码分析

4.1 executor方法

向线程池提交任务的方法是execute方法，execute方法是ThreadPoolExecutor的核心方法

public void execute(Runnable command) {
 if (command == null)
     throw new NullPointerException();
 // 获取ctl的值
 int c = ctl.get();
 // 1.线程数小于corePoolSize
 if (workerCountOf(c) < corePoolSize) {
     // 线程池中线程数小于核心线程数，则尝试创建核心线程执行任务
     if (addWorker(command, true))
         return;
     c = ctl.get();
 }
 // 2.到此处说明线程池中线程数大于核心线程数或者创建线程失败
 if (isRunning(c) && workQueue.offer(command)) {
     // 如果线程是运行状态并且可以使用offer将任务加入阻塞队列未满，offer是非阻塞操作。
     int recheck = ctl.get();
     // 重新检查线程池状态，因为上次检测后线程池状态可能发生改变，如果非运行状态就移除任务并执行拒绝策略
     if (! isRunning(recheck) && remove(command))
         reject(command);
     // 如果是运行状态，并且线程数是0，则创建线程
     else if (workerCountOf(recheck) == 0)
         // 线程数是0，则创建非核心线程，且不指定首次执行任务，这里的第二个参数其实没有实际意义
         addWorker(null, false);
 }
 // 3.阻塞队列已满，创建非核心线程执行任务
 else if (!addWorker(command, false))
     // 如果失败，则执行拒绝策略
     reject(command);
}

未完待续

参考资料：
1丶https://juejin.cn/post/6983213662383112206/#heading-9
2丶https://juejin.cn/post/6971334859717345311#heading-0

Java 基础和常用类

03丶线程池

一基础知识

1.1 线程池的优势

1.2 线程池的使用

1.3 生命周期

1.4 七大参数

二工作机制

2.1 工作流程

2.2 拒绝策略

三手写线程池

3.1 配置线程池参数

四 Spring与线程池

4.1 小案例

4.2 Spring实现的线程池

4.3 @Async修饰的异步方法

五源码分析

4.1 executor方法

03丶线程池

一 基础知识

1.1 线程池的优势

1.2 线程池的使用

1.3 生命周期

1.4 七大参数

二 工作机制

2.1 工作流程

2.2 拒绝策略

三 手写线程池

3.1 配置线程池参数

四 Spring与线程池

4.1 小案例

4.2 Spring实现的线程池

4.3 @Async修饰的异步方法

五 源码分析

4.1 executor方法

一基础知识

二工作机制

三手写线程池

五源码分析