线程是在一个进程中可以执行一系列指令的执行环境，或称运行程序。多线程编程指的是用多个线程并行执行多个任务。当然，JVM 对多线程有良好的支持。
尽管这带来了诸多优势，首当其冲的就是程序性能提高，但多线程编程也有缺点 —— 增加了代码复杂度、同步问题、非预期结果和增加创建线程的开销。这次，我们来了解一下如何使用 Java 线程池来缓解这些问题。
为什么使用线程池？
创建并开启一个线程开销很大。如果我们每次需要执行任务时重复这个步骤，那将会是一笔巨大的性能开销，这也是我们希望通过多线程解决的问题。
为了更好理解创建和开启一个线程的开销，让我们来看一看 JVM 在后台做了哪些事：
- 为线程栈分配内存，保存每个线程方法调用的栈帧。
- 每个栈帧包括本地变量数组、返回值、操作栈和常量池
- 一些 JVM 支持本地方法，也将分配本地方法栈
- 每个线程获得一个程序计数器，标识处理器正在执行哪条指令
- 系统创建本地线程，与 Java 线程对应
- 和线程相关的描述符被添加到 JVM 内部数据结构
- 线程共享堆和方法区
java.util.concurrent 包中有以下接口
- Executor —— 执行任务的简单接口
- ExecutorService —— 一个较复杂的接口，包含额外方法来管理任务和 executor 本身
- ScheduledExecutorService —— 扩展自 ExecutorService，增加了执行任务的调度方法
除了这些接口，这个包中也提供了 Executors 类直接获取实现了这些接口的 executor 实例
Executors 类和 Executor 接口
Executors 类包含工厂方法创建不同类型的线程池，Executor 是个简单的线程池接口，只有一个 execute() 方法。
Executors 类里的工厂方法可以创建很多类型的线程池：
- newSingleThreadExecutor()：包含单个线程和无界队列的线程池，同一时间只能执行一个任务
- newFixedThreadPool()：包含固定数量线程并共享无界队列的线程池；当所有线程处于工作状态，有新任务提交时，任务在队列中等待，直到一个线程变为可用状态
- newCachedThreadPool()：只有需要时创建新线程的线程池
- newWorkStealingThreadPool()：基于工作窃取（work-stealing）算法的线程池。
Callable
Callable() 函数返回的类型就是传递进来的 V 类型。
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
Future
Future 就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get 方法获取执行结果，该方法会阻塞直到任务返回结果。
Future 类位于java.util.concurrent 包下，它是一个接口：
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
在 Future接口中声明了 5 个方法，下面依次解释每个方法的作用：
cancel 方法用来取消任务，如果取消任务成功则返回 true，如果取消任务失败则返回 false。
参数 mayInterruptIfRunning 表示是否允许取消正在执行却没有执行完毕的任务。如果设置 true，则表示可以取消正在执行过程中的任务。
如果任务还没有执行，则无论 mayInterruptIfRunning 为 true 还是 false，肯定返回 true。
如果任务正在执行，若 mayInterruptIfRunning 设置为 true，则返回true，若 mayInterruptIfRunning 设置为 false，则返回 false；
如果任务已经完成，则无论 mayInterruptIfRunning 为 true 还是 false，此方法肯定返回 false。即如果取消已经完成的任务会返回 false。isCancelled 方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
isDone 方法表示任务是否已经完成，若任务完成，则返回 true；
get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
get(long timeout, TimeUnit unit) 用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回 null。
也就是说 Future 提供了三种功能：
- 判断任务是否完成；
- 能够中断任务；
- 能够获取任务执行结果。
因为 Future 只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的 FutureTask。
FutureTask 的实现
public class FutureTask<V> implements RunnableFuture<V>
FutureTask 类实现了 RunnableFuture 接口，我们看一下 RunnableFuture 接口的实现：
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
可以看出 RunnableFuture 继承了 Runnable 接口和 Future 接口，而 FutureTask 实现了 RunnableFuture 接口。所以它既可以作为Runnable 被线程执行，又可以作为 Future 得到 Callable 的返回值。
ShutDown和ShutDownNow的区别
从字面意思就能理解，shutdownNow()能立即停止线程池，正在跑的和正在等待的任务都停下了。这样做立即生效，但是风险也比较大；
shutdown()
将线程池状态置为 SHUTDOWN，并不会立即停止。它停止接收外部 submit 的任务，内部正在跑的任务和队列里等待的任务，会执行完。
shutdownNow()
将线程池状态置为 STOP。企图立即停止，事实上不一定：
跟shutdown()一样，先停止接收外部提交的任务
忽略队列里等待的任务
尝试将正在跑的任务 interrupt 中断
返回未执行的任务列表
awaitTermination(long timeOut, TimeUnit unit)
当前线程阻塞，直到等所有已提交的任务（包括正在跑的和队列中等待的）执行完
或者等超时时间到
或者线程被中断，抛出 InterruptedException
然后返回 true（shutdown 请求后所有任务执行完毕）或 false（已超时）
总结
- 优雅的关闭，用shutdown(), 之后不能再提交新的任务进去
- 想立马关闭，并得到未执行任务列表，用shutdownNow()
awaitTermination()并不具有提交的功能, awaitTermination()是阻塞的，返回结果是线程池是否已停止（true/false）；shutdown()不阻塞。
关闭功能 【从强到弱】 依次是：shuntdownNow() > shutdown() > awaitTermination()
ThreadPoolExecutor 构造方法
// Java 线程池的完整构造函数
public ThreadPoolExecutor(
int corePoolSize, // 线程池长期维持的线程数，即使线程处于 Idle 状态，也不会回收。
int maximumPoolSize, // 线程数的上限
long keepAliveTime, TimeUnit unit, // 超过corePoolSize的线程的 idle 时长，超过这个时间，多余的线程会被回收。
BlockingQueue<Runnable> workQueue, // 任务的排队队列
ThreadFactory threadFactory, // 新线程的产生方式
RejectedExecutionHandler handler) // 拒绝策略
线程池的工作顺序
If fewer than corePoolSize threads are running, the Executor always prefers adding a new thread rather than queuing.
If corePoolSize or more threads are running, the Executor always prefers queuing a request rather than adding a new thread.
If a request cannot be queued, a new thread is created unless this would exceed maximumPoolSize, in which case, the task will be rejected.
- 如果运行的线程少于 corePoolSize，则Executor始终首选添加新的线程，而不进行排队。
- 如果运行的线程等于或多于 corePoolSize，则Executor始终首选将请求加入队列，而不添加新的线程。
- 如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝（抛出RejectedExecutionException）。
如何正确使用线程池
避免使用无界队列
不要使用 Executors.newXXXThreadPool()快捷方法创建线程池，因为这种方式会使用无界的任务队列，为避免 OOM，我们应该使用 ThreadPoolExecutor 的构造方法手动指定队列的最大长度.
明确拒绝任务时的行为
任务队列总有占满的时候，这是再 submit() 提交新的任务会怎么样呢？RejectedExecutionHandler接口为我们提供了控制方式，接口定义如下：
public interface RejectedExecutionHandler {
void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
线程池默认的拒绝行为是 AbortPolicy，也就是抛出 RejectedExecutionHandler 异常，该异常是非受检异常，很容易忘记捕获。如果不关心任务被拒绝的事件，可以将拒绝策略设置成DiscardPolicy，这样多余的任务会悄悄的被忽略。
策略使用的 Demo
public static void main(String[] args) {
final int corePoolSize = 1;
final int maxPoolSize = 2;
BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>(1);
// 拒绝策略1：将抛出 RejectedExecutionException. 此处可以切换成其他策略
ThreadPoolExecutor executor = new ThreadPoolExecutor
(corePoolSize,maxPoolSize, 5,TimeUnit.SECONDS, queue,
new ThreadPoolExecutor.AbortPolicy());
for(int i=0; i<4; i++) {
executor.execute(new Worker());
}
executor.shutdown();
}
public static void testShutDown(int startNo) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(2);
for (int i = 0; i < 5; i++) {
executorService.execute(getTask(i + startNo));
}
executorService.shutdown();
// awaitTermination是阻塞方法
executorService.awaitTermination(1, TimeUnit.DAYS);
System.out.println("shutDown->all thread shutdown");
}
获取处理结果和异常
线程池的处理结果、以及处理过程中的异常都被包装到 Future 中，并在调用 Future.get() 方法时获取，执行过程中的异常会被包装成 ExecutionException，submit() 方法本身不会传递结果和任务执行过程中的异常。获取执行结果的代码可以这样写：
ExecutorService executorService = Executors.newFixedThreadPool(4);
Future<Object> future = executorService.submit(new Callable<Object>() {
@Override
public Object call() throws Exception {
throw new RuntimeException("exception in call~");// 该异常会在调用Future.get()时传递给调用者
}
});
try {
Object result = future.get();
} catch (InterruptedException e) {
// interrupt
} catch (ExecutionException e) {
// exception in Callable.call()
e.printStackTrace();
正确构造线程池
int poolSize = Runtime.getRuntime().availableProcessors() * 2;
BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(512);
RejectedExecutionHandler policy = new ThreadPoolExecutor.DiscardPolicy();
executorService = new ThreadPoolExecutor(poolSize, poolSize,
0, TimeUnit.SECONDS, queue, policy);
获取单个结果
过submit()向线程池提交任务后会返回一个Future，调用V Future.get()方法能够阻塞等待执行结果，V get(long timeout, TimeUnit unit)方法可以指定等待的超时时间。
获取多个结果
如果向线程池提交了多个任务，要获取这些任务的执行结果，可以依次调用Future.get()获得。但对于这种场景，我们更应该使用 ExecutorCompletionService，该类的take()方法总是阻塞等待某一个任务完成，然后返回该任务的Future对象。向CompletionService批量提交任务后，只需调用相同次数的CompletionService.take()方法，就能获取所有任务的执行结果，获取顺序是任意的，取决于任务的完成顺序：
void solve(Executor e,
Collection<Callable<Result>> solvers)
throws InterruptedException, ExecutionException {
CompletionService<Result> cs
= new ExecutorCompletionService<>(e);
solvers.forEach(cs::submit);
for (int i = solvers.size(); i > 0; i--) {
Result r = cs.take().get();
if (r != null)
use(r);
}
}
单个任务的超时时间
V Future.get(long timeout, TimeUnit unit)方法可以指定等待的超时时间，超时未完成会抛出TimeoutException。
多个任务的超时时间
等待多个任务完成，并设置最大等待时间，可以通过CountDownLatch完成：
public void testLatch(ExecutorService executorService, List<Runnable> tasks)
throws InterruptedException{
CountDownLatch latch = new CountDownLatch(tasks.size());
for(Runnable r : tasks){
executorService.submit(new Runnable() {
@Override
public void run() {
try{
r.run();
}finally {
latch.countDown();// countDown
}
}
});
}
latch.await(10, TimeUnit.SECONDS); // 指定超时时间
}
参考
深入学习 Java 线程池
http://www.importnew.com/29212.html
threadPoolExecutor 中的 shutdown() 、 shutdownNow() 、 awaitTermination() 的用法和区别
https://blog.csdn.net/u012168222/article/details/52790400
