【多线程】为什么不建议使用Executors来创建线程池？

- - - 一、线程池类型
    - - 1.1 固定数量的线程池
      - 1.2 单个线程线程池
      - 1.3 带缓冲的线程池
      - 1.4 延迟任务线程池
    - 二、代码示例
    - - 2.1 固定数量的线程池
      - 2.2 单个线程的线程池
      - 2.3 带缓冲的线程池
      - 2.4 延迟线程池

一、线程池类型

1.1 固定数量的线程池

1.创建的队列为LinkedBlockingQueue，是一个无界阻塞队列，可以放任意数量的任务
2.使用固定数量的线程池执行任务，当任务过多会不断添加到任务队列中，任务越多占用的内存就越多，会耗尽内存导致oom
3.核心线程数等于最大线程数，没有救急线程，无需超时时间
4.适用于任务量已知，相对耗时的任务

1.2 单个线程线程池

1.多个任务排队执行
2.线程数固定为1，任务数多于1时，会放入无界队列排队
3.任务执行完毕，唯一的线程也不会释放
4.与自己创建的线程的区别：自己创建一个单线程串行执行任务，任务执行失败而终止则没有任务不就措施，线程池执行失败会新建一个线程，保证线程池的正常工作
5.线程个数始终为1，后续不能修改；固定数量的线程池初始为1，后续还可以修改。单个线程线程池创建时FinalizableDelegatedExecutorService用的是装饰器模式，只对外暴露ExecutorService接口，不能调用ThreadPoolExecutor中特有的方法，固定数量线程池对外暴露的是ThreadPoolExecutor对象，可以强转，调用setCorePoolSize等方法进行修改

1.3 带缓冲的线程池

1.核心线程数是0，最大线程数是Integer.MAX_VALUE，救急线程的空闲生存时间是60s
2.全部是救急线程（60秒后可以回收）
3.可以无限创建救急线程
4.队列采用了同步队列SynchronousQueue [ˈsɪŋkrənəs]，没有容量，任务放入队列若是没有线程来取任务，任务是放不进去的
5.整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲1分钟后释放线程
6.适合任务数比较密集，每个任务执行时间较短的情况

1.4 延迟任务线程池

1.可以延迟执行任务
2.DelayedWorkQueue延迟队列
3.无界队列，可能会导致OOM

二、代码示例

2.1 固定数量的线程池

// 创建一个3个线程数量的线程池
ExecutorService executorService = Executors.newFixedThreadPool(3);

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

2.2 单个线程的线程池

ExecutorService executorService = Executors.newSingleThreadExecutor();

// 源码
public static ExecutorService newSingleThreadExecutor() {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));
}

// 单线程池执行失败，会创建新的线程来执行后续的任务
package com.learning.threadpool;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** @Description 单线程的线程池执行失败会创建新线程继续处理后续任务**/
public class SingleThreadPool {public static void main(String[] args) {ExecutorService executorService = Executors.newSingleThreadExecutor();for (int i = 0; i < 3; i++) {int finalI = i;executorService.execute(()->{if(finalI==0){int a = finalI / 0;}System.out.println(finalI);});}}
}

2.3 带缓冲的线程池

ExecutorService executorService = Executors.newCachedThreadPool();

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

2.4 延迟线程池

// 源码
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {return new ScheduledThreadPoolExecutor(corePoolSize);
}

package com.learning.threadpool;import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;/*** @Description 延迟线程池**/
public class NewScheduledThreadPool {public static void main(String[] args) {ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);System.out.println("开始");for (int i = 0; i < 10; i++) {int finalI = i;scheduledExecutorService.schedule(()->{System.out.println(finalI);}, 5, TimeUnit.SECONDS);}}
}