前言：默认线程池的弊端

在线程池应用中，参考阿里巴巴java开发规范：线程池不允许使用Executors去创建，不允许使用系统默认的线程池，推荐通过ThreadPoolExecutor的方式，这样的处理方式让开发的工程师更加明确>线程池的运行规则，规避资源耗尽的风险。Executors各个方法的弊端：

newFixedThreadPool和newSingleThreadExecutor：主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。

newCachedThreadPool和newScheduledThreadPool：主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。

线程池中提交线程的方法，一种是execute()另外一种是submit()

1：2种方法接收的参数不同

2：submit()有返回值，execute()没有

3：submit()方法便于Exception处理

4：execute()：提交不需要返回值的任务，无法判断任务是否被执行成功了

5：submit()：提交需要放回值的任务；线程会返回Future对象，通过Future的isDone()方法可以判断任务是否执行成功，并且可以通过Future.get()获取返回的值，get方法会阻塞，直到线程的完成

而get(long timeout, TimeUnit unit)会在等待一段时间后返回，这段时间内任务可能没有执行完成

线程池的创建可以分为以下两类

1：通过 ThreadPoolExecutor 手动创建线程池

2：通过 Executors 执行器自动创建线程池

1：FixedThreadPool

创建一个固定大小的线程池，可控制并发线程数。

使用 FixedThreadPool 创建 2 个固定大小的线程池

public static void fixedThreadPool() {// 创建 2 个线程的线程池ExecutorService threadPool = Executors.newFixedThreadPool(2);// 创建任务Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println("任务被执行,线程:" + Thread.currentThread().getName());}};threadPool.execute(runnable); threadPool.execute(runnable); threadPool.execute(runnable);threadPool.execute(runnable);
}//如果觉得以上方法比较繁琐，还用使用以下简单的方式来实现线程池的创建和使用：
public static void fixedThreadPool() {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(2);// 执行任务threadPool.execute(() -> {System.out.println("任务被执行,线程:" + Thread.currentThread().getName());});
}

2：CachedThreadPool

创建一个可缓存的线程池，若线程数超过任务所需，那么多余的线程会被缓存一段时间后才被回收，若线程数不够，则会新建线程。有多少任务就动态创建多少线程，线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。CachedThreadPool 是根据短时间的任务量来决定创建的线程数量的，所以它适合短时间内有突发大量任务的处理场景

public static void cachedThreadPool() {// 创建线程池ExecutorService threadPool = Executors.newCachedThreadPool();// 执行任务for (int i = 0; i < 10; i++) {threadPool.execute(() -> {System.out.println("执行任务,线程:" + Thread.currentThread().getName());try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}});}
}

3：SingleThreadExecutor

创建单个线程的线程池，它可以保证线程先进先出的执行顺序

单个线程的线程池相比于线程来说，它的优点有以下 2 个：

1：可以复用线程：即使是单个线程池，也可以复用线程。

2：提供了任务管理功能：单个线程池也拥有任务队列，在任务队列可以存储多个任务，这是线程无法实现的，并且当任务队列满了之后，可以执行拒绝策略，这些都是线程不具备的。

public static void singleThreadExecutor() {// 创建线程池ExecutorService threadPool = Executors.newSingleThreadExecutor();// 执行任务for (int i = 0; i < 10; i++) {final int index = i;threadPool.execute(() -> {System.out.println(index + ":任务被执行");try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}});}
}

4：ScheduledThreadPool

创建一个可以执行延迟任务的线程池

执行结果是，任务在 2 秒之后被执行了，实现了延迟 1s 再执行任务

public static void scheduledThreadPool() {// 创建线程池ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);// 添加定时执行任务(2s 后执行)System.out.println("添加任务,时间:" + new Date());threadPool.schedule(() -> {System.out.println("任务被执行,时间:" + new Date());try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}}, 2, TimeUnit.SECONDS);
}

5：ThreadPoolExecutor

ThreadPoolExecutor 是最原始、也是最推荐的手动创建线程池的方式，它在创建时最多提供 7 个参数可供设置

public static void myThreadPoolExecutor() {// 创建线程池ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, //corePoolSize 核心线程数10, //MaxPS  最大线程数100, //keepAliveTime  存活时间TimeUnit.SECONDS, //TimeUnit  时间单位new LinkedBlockingQueue<>(10),//BlockingQueue  任务队列Executors.defaultThreadFactory(),//ThreadFactory  线程工厂new ThreadPoolExecutor.DiscardPolicy());//RejectStrategy  拒绝策略// 执行任务
}

corePoolSize：线程池核心线程数（平时保留的线程数）
maximumPoolSize：线程池最大线程数（当workQueue都放不下时，启动新线程，最大线程数）
keepAliveTime：超出corePoolSize数量的线程的保留时间。
unit：keepAliveTime单位
workQueue：阻塞队列，存放来不及执行的线程
ArrayBlockingQueue：构造函数一定要传大小
LinkedBlockingQueue：构造函数不传大小会默认为（Integer.MAX_VALUE ），当大量请求任务时，容易造成 内存耗尽。
SynchronousQueue：同步队列，一个没有存储空间的阻塞队列 ，将任务同步交付给工作线程。
PriorityBlockingQueue : 优先队列
threadFactory：线程工厂
handler：饱和策略,当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略
AbortPolicy（默认）：该策略下，直接丢弃任务，并抛出RejectedExecutionException异常
CallerRunsPolicy：用调用者的线程执行任务，该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务
DiscardOldestPolicy：该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列
DiscardPolicy：该策略下，直接丢弃任务，什么都不做