利用Executors类来创建三种线程池
这三种线程池分别是FixedThreadPool，SingleThreadPool，CachedThreadPool
| 类型 | 特点 |
|---|---|
| FixedThreadPool | 可以指定固定的线程数的线程池 |
| SingleThreadPool | 只提供一个线程的线程池 |
| CachedThreadPool | 能根据当前业务繁忙情况动态地增加和减少线程数的线程池 |
代码演示
/**
*
* @Title: testThree
* @Description: 用Executors类创建三种线程池
* @return: void
*/
public static void testThree() {
//利用Executors类可以创建三种线程池：固定线程数，1个线程，动态伸缩线程数
//固定线程数的线程池（这里给它5个线程）
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
try {
for(int i = 0; i < 10; i++) {
fixedThreadPool.execute(()->{
System.out.println("fixedThreadPool " + Thread.currentThread().getName() + "正在执行...");
});
}
} finally {
fixedThreadPool.shutdown();
}
//只包含一个线程的线程池
// ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
// try {
// for(int i = 0; i < 10; i++) {
// singleThreadPool.execute(()->{
// System.out.println("singleThreadPool " + Thread.currentThread().getName() + "正在执行...");
// });
// }
// } finally {
// singleThreadPool.shutdown();
// }
//
// //动态伸缩线程数的线程池
// ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// try {
// for(int i = 0; i < 10; i++) {
// cachedThreadPool.execute(()->{
// System.out.println("cachedThreadPool " + Thread.currentThread().getName() + "正在执行...");
// });
// TimeUnit.SECONDS.sleep(1);
// }
// } catch (InterruptedException e) {
//
// e.printStackTrace();
// } finally {
// cachedThreadPool.shutdown();
// }
}
这三种线程池其实底层都是调用了ThreadPoolExecutor类的同一个构造方法
//newFixedThreadPool(int nThreads)的源码
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
//newSingleThreadExecutor()的源码
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
//newCachedThreadPool的源码
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
可以看出，这三种线程池其实都可以看成是一种
ThreadPoolExecutor构造方法七个参数的含义
前面的三种线程池的底层都是调用的ThreadPoolExecutor五个参数的构造方法，我们点进去这个构造方法，发现其调用的是ThreadPoolExecutor七个参数的构造方法
/**
* The default rejected execution handler
*/
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
//五个参数的构造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
//七个参数的构造方法
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;
}
我们重点来看看这七个参数的含义
int corePoolSize //线程池中的核心常驻线程数
int maximumPoolSize //线程池中同时运行的最大线程数（核心常驻线程+非核心线程）
long keepAliveTime //最大空闲时间，超过这个时间都空闲的非常驻线程都会被回收
TimeUnit unit //配合keepAliveTime使用，是其的时间单位
BlockingQueue<Runnable> workQueue //用来存放Runnable任务的阻塞队列
ThreadFactory threadFactory //产生线程的线程工厂，一般使用默认的（Executors.defaultThreadFactory()）即可
RejectedExecutionHandler handler //拒绝策略，当线程池已经启用最大线程数并且阻塞队列已满时会触发拒绝策略，处理那些无法及时处理的任务
线程池的构造原理
线程池 == 许多可循环利用的线程 + 队列（存放Runable任务）
线程池结构
线程池工作流程图解
1.来了两个任务，两个核心常驻线程分别处理这两个任务
2.又来了两个任务，发现现在能提供服务的线程均被占用着，于是这两个任务进入队列排队等待
3.又过来3个任务，刚好把队列占满了，于是看了看还有没有非核心线程未启动，发现还有，于是就启动非核心线程，把队列前三个任务分给三个非核心线程处理
4.这时候又来了3个任务，又一次把队列塞满
5.又来了一个任务，发现所有可以处理任务的线程都已经被占用了，又看了看队列，发现队列也满了，再看看有没有非核心线程可以开启，发现非核心线程也被占用完了，于是线程池启动拒绝策略，由拒绝策略决定如何处理这个任务
6.过了一段时间，任务都处理得差不多了，非核心线程空闲了下来，一旦非核心线程空闲超过keepAliveTime指定的时间，那这些非空闲线程将会被回收，重新回到不启用的状态
总结线程池的主要处理流程
几种拒绝策略
| 拒绝策略 | 说明 |
|---|---|
| AbortPolicy(默认策略) | 直接抛出异常阻止系统正常运行 |
| CallerRunsPolicy | 该策略既不会抛弃任务也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量 |
| DiscardOldestPolicy | 抛弃队列中等待最久的任务，然后把当前任务加入队列中，尝试再次提交当前任务 |
| DiscardPolicy | 该策略默默地丢弃无法处理的任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种策略 |
工作中我们应该选择创建哪种线程池呢
答案是：我们尽量不要使用Executors类来创建线程池
我们可以查看Executors类创建这三种线程池的源码
FixedThreadPool
new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>())
可以看到第五个参数是一个阻塞队列，但该队列并没有显示提供最大容量，我们看一下它默认给的最大容量
/**
* Creates a {@code LinkedBlockingQueue} with a capacity of
* {@link Integer#MAX_VALUE}.
*/
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
该队列默认给的最大容量为Integer.MAX_VALUE，这个队列将“无限”地增大，这将造成大量任务塞在队列里得不到及时处理，而且可能会造成OOM内存溢出
SingleThread
new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
通过源码可知，SingleThread也存在和FixedThreadPool一样的问题
CachedThreadPool
new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
可以看到，其第二个参数说明了该线程池的最大容量是Integer.MAX_VALUE，这是一个非常庞大的数字，一旦出现高并发，该线程池就会创建数量庞大的线程，很容易就出现OOM内存溢出
自定义线程池（工作中推荐使用）
由于通过Executors类创建的这三种线程池有各种问题，我们并不能够干预它，所以，推荐直接通过
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
构造方法创建一个线程池，线程池的各项配置我们可以直接通过传参的方式来定制和修改
按照上面“线程池工作流程图解”里线程池的配置自定义了一个线程池
new ThreadPoolExecutor(2, 5, 1, TimeUnit.SECOND, new LinkedBlockingQueue<Runnable>(5),
Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());