Java 线程池

概述

1、什么是线程池

线程池就是首先创建一些线程，它们的集合称为线程池，使用线程池可以很好的提高性能。线程池在系统启动时就创建大量空闲的线程，程序将一个任务传给线程池。线程池就会启动一条线程来执行这个任务，执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

2、为什么使用线程池

在执行异步任务或并发任务时，如果通过 new Thread() 方式创建新的线程，当系统不断的启动和关闭新线程以及过渡切换线程，会过度消耗系统资源，成本非常高，从而导致系统资源的崩溃，这时线程池也就是最好的选择。

3、合理使用线程池能带来的好处

（1）降低资源消耗。 通过重复利用已经创建的线程降低线程创建的和销毁造成的消耗。例如，工作线程 Woker 会无线循环获取阻塞队列中的任务来执行。
（2）提高响应速度。 当任务到达时，任务可以不需要等到线程创建就能立即执行。 （3）提高线程的可管理性。线程是稀缺资源，Java 的线程池可以对线程资源进行统一分配、调优和监控。

线程池使用

1、线程池创建与使用

线程池的创建方法总共有 7 种，但总体来说可分为 2 类：一类是通过 ThreadPoolExecutor 创建的线程池；另一个类是通过 Executors 创建的线程池。

（1）ThreadPoolExecutor 创建

public ThreadPoolExecutor(int corePoolSize,
                           int maximumPoolSize,
                           long keepAliveTime,
                           TimeUnit unit,
                           BlockingQueue<Runnable> workQueue,
                           ThreadFactory threadFactory,
                           RejectedExecutionHandler handler) {
     // 省略... 
   } 

// 举例：
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 	// corePoolSize
													 10, 	// maximumPoolSize
													 200, 	// keepAliveTime
													 TimeUnit.MILLISECONDS,	// unit
                                                     new ArrayBlockingQueue<Runnable>(5)	// workQueue
        										     );

线程池的参数讲解
（1）corePoolSize

线程池核心线程大小。线程池维护的最小线程数量，核心线程创建后不会被回收（注意：设置allowCoreThreadTimeout=true后，空闲的核心线程超过存活时间也会被回收）。

（2）maximumPoolSize

最大线程数。线程池允许创建的最大线程数量。
当添加一个任务时，核心线程数已满，线程池还没达到最大线程数，并且没有空闲线程，工作队列已满的情况下，创建一个新线程并执行。

（3）keepAliveTime

空闲线程存活时间。当一个可被回收的线程的空闲时间大于keepAliveTime，就会被回收。
可被回收的线程：
1）设置allowCoreThreadTimeout=true的核心线程。
2）大于核心线程数的线程（非核心线程）。

（4）TimeUnit

unit 空闲线程存活时间单位
keepAliveTime的计量单位

（5）workQueue

工作队列。存放待执行任务的队列：当提交的任务数超过核心线程数大小后，再提交的任务就存放在工作队列，任务调度时再从队列中取出任务。它仅仅用来存放被 execute() 方法提交的 Runnable 任务。工作队列实现了 BlockingQueue 接口。
JDK 默认的工作队列有五种：

1） ArrayBlockingQueue 数组型阻塞队列：数组结构，初始化时传入大小，有界，FIFO，使用一个重入锁，默认使用非公平锁，入队和出队共用一个锁，互斥。
2）LinkedBlockingQueue 链表型阻塞队列：链表结构，默认初始化大小为Integer.MAX_VALUE，有界（近似无解），FIFO，使用两个重入锁分别控制元素的入队和出队，用Condition进行线程间的唤醒和等待。
3）SynchronousQueue 同步队列：容量为0，添加任务必须等待取出任务，这个队列相当于通道，不存储元素。
4）PriorityBlockingQueue 优先阻塞队列：无界，默认采用元素自然顺序升序排列。
5）DelayQueue 延时队列：无界，元素有过期时间，过期的元素才能被取出。

（6）threadFactory

线程工厂。创建线程的工厂，可以设定线程名、线程编号等。

（7）handler

拒绝策略。当线程池线程数已满，并且工作队列达到限制，新提交的任务使用拒绝策略处理。可以自定义拒绝策略，拒绝策略需要实现RejectedExecutionHandler接口。
JDK默认的拒绝策略有四种：

1）AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。
2）DiscardPolicy：丢弃任务，但是不抛出异常。可能导致无法发现系统的异常状态。
3）DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。
4）CallerRunsPolicy：由调用线程处理该任务。

（2）FixedThreadPool

创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待；

ExecutorService threadPool = Executors.newFixedThreadPool(2);

// 执行任务的方法有两种:submit 和 execute 
threadPool.submit(runnable);  // 执行方式1:submit 
threadPool.execute(runnable); // 执行方式 2:execute 

（3）CachedThreadPool

创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程；

// 创建线程池 
ExecutorService threadPool = Executors.newCachedThreadPool(); 
// 执行任务 
threadPool.execute(runnable);

（4）SingleThreadExecutor()

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

ExecutorService threadPool = Executors.newSingleThreadExecutor();
threadPool.execute(runnable);

（5）ScheduledThreadPool

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

ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
threadPool.schedule(runnable);

（6）SingleThreadScheduledExecutor

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

ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
threadPool.schedule(runnable);

（7）WorkStealingPool

创建一个抢占式执行的线程池（任务执行顺序不确定）【JDK 1.8 添加】。

ScheduledExecutorService threadPool = Executors.newWorkStealingPool();
threadPool.execute(runnable);

2、线程池的工作流程

在线程池模式下，任务不是直接提交给某个线程而是提交给整个线程池，流程如下：

（1）判断核心线程池是否已满，即已创建线程数是否小于corePoolSize？没满则创建一个新的工作线程来执行任务。已满则进入下个流程。
（2）判断工作队列是否已满？没满则将新提交的任务添加在工作队列，等待执行。已满则进入下个流程。
（3）判断整个线程池是否已满，即已创建线程数是否小于maximumPoolSize？没满则创建一个新的工作线程来执行任务，已满则交给饱和策略来处理这个任务。

3、线程池的选用

阿里巴巴《Java开发手册》：

【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
Executors 返回的线程池对象的弊端如下：

1） FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2）CachedThreadPool：允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

推荐使用的是 ThreadPoolExecutor 的方式进行线程池的创建，ThreadPoolExecutor 最多可以设置 7 个参数，当然设置 5 个参数也可以正常使用，ThreadPoolExecutor 当任务过多（处理不过来）时提供了 4 种拒绝策略，当然我们也可以自定义拒绝策略