并发编程之深入浅析Executor框架

本文参考自《并发编程艺术》
在Java中，使用线程来异步执行任务。Java线程的创建与销毁需要一定的开销，如果我们为每一个任务创建一个新线程来执行，这些线程的创建与销毁将消耗大量的计算资源。同时，为每一个任务创建一个新线程来执行，这种策略可能会使处于高负荷状态的应用最终崩溃。
Java的线程既是工作单元，也是执行机制。从JDK 5开始，把工作单元与执行机制分离开来。工作单元包括Runnable和Callable，而执行机制由Executor框架提供。

一、Executor框架简介

在介绍Executor框架之前，有必要介绍下Executor框架的基本模型

1.1 Executor框架的两级调度模型

Java线程启动时会创建一个本地操作系统线程；当该Java线程终止时，这个操作系统线程也会被回收。操作系统会调度所有线程并将它们分配给可用的CPU。
在上层，Java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（Executor框架）将这些任务映射为固定数量的线程；在底层，操作系统内核将这些线程映射到硬件处理器上。这种两级调度模型的示意图如下图所示

可见，应用程序通过Executor框架控制上层的调度；而下层的调度由操作系统内核控制，下层的调度不受应用程序的控制。

1.2 Executor框架的结构

Executor框架主要由3大部分组成如下：
1. 任务。包括被执行任务需要实现的接口：Runnable接口或Callable接口。
2. 任务的执行。包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接口（ThreadPoolExecutor和ScheduledThreadPoolExecutor）。
3. 异步计算的结果。包括接口Future和实现Future接口的FutureTask类。
下面简单介绍下这些类和接口：
·Executor是一个接口，它是Executor框架的基础，它将任务的提交与任务的执行分离开来。
·ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。
·ScheduledThreadPoolExecutor 是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor比Timer更灵活，功能更强大。
·Future接口和实现Future接口的FutureTask类，代表异步计算的结果。
·Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或Scheduled-ThreadPoolExecutor执行。
继承图如下：

1.3 Executor框架

Executor框架的使用调度结构图如下：

接下来我们来分析下上图的执行流程：

1. 主线程首先要创建实现Runnable或者Callable接口的任务对象。工具类Executors可以把一个Runnable对象封装为一个Callable对象（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule））。
2. 然后可以把Runnable对象直接交给ExecutorService执行（ExecutorService.execute（Runnablecommand））；或者也可以把Runnable对象或Callable对象提交给ExecutorService执行（Executor-Service.submit（Runnable task）或ExecutorService.submit（Callabletask））。
3. 如果执行ExecutorService.submit（…），ExecutorService将返回一个实现Future接口的对象。由于FutureTask实现了Runnable，程序员也可以创建FutureTask，然后直接交给ExecutorService执行。
4. 最后，主线程可以执行FutureTask.get()方法来等待任务执行完成。主线程也可以执行FutureTask.cancel（boolean mayInterruptIfRunning）来取消此任务的执行。

二、ThreadPoolExecutor详解

Executor框架最核心的类是ThreadPoolExecutor，它是线程池的实现类，能够创建3种类型的ThreadPoolExecutor。分别是：

1. FixedThreadPool
2. SingleThreadExecutor
3. CachedThreadPool

这三个的讲解，笔者推荐一篇博客，介绍的比较全面，和在《并发编程艺术》一书上的介绍无大差距笔者就不重复造轮子了，推荐以下文章：
博客链接https://blog.csdn.net/javazejian/article/details/50890554

三、FutureTask详解

Future接口和实现Future接口的FutureTask类，代表异步计算的结果。

3.1 FutureTask简介

FutureTask除了实现Future接口外，还实现了Runnable接口。因此，FutureTask可以交给Executor执行，也可以由调用线程直接执行（FutureTask.run()）。根据FutureTask.run()方法被执行的时机，FutureTask可以处于下面3种状态。

1. 未启动。FutureTask.run()方法还没有被执行之前，FutureTask处于未启动状态。当创建一个FutureTask，且没有执行FutureTask.run()方法之前，这个FutureTask处于未启动状态。
2. 已启动。FutureTask.run()方法被执行的过程中，FutureTask处于已启动状态。
3. 已完成。FutureTask.run()方法执行完后正常结束，或被取消（FutureTask.cancel（…）），或执行FutureTask.run()方法时抛出异常而异常结束，FutureTask处于已完成状态。

以下给出状态切换图

当FutureTask处于未启动或已启动状态时，执行FutureTask.get()方法将导致调用线程阻塞（调用这个方法的线程阻塞）；当FutureTask处于已完成状态时，执行FutureTask.get()方法将导致调用线程立即返回结果或抛出异常。
当FutureTask处于未启动状态时，执行FutureTask.cancel()方法将导致此任务永远不会被执行；当FutureTask处于已启动状态时，执行FutureTask.cancel（true）方法将以中断执行此任务线程的方式来试图停止任务；当FutureTask处于已启动状态时，执行FutureTask.cancel（false）方法将不会对正在执行此任务的线程产生影响（让正在执行的任务运行完成）；当FutureTask处于已完成状态时，执行FutureTask.cancel（…）方法将返回false。
示意图如下

3.2 FutureTask的使用

可以把FutureTask交给Executor执行；也可以通过ExecutorService.submit（…）方法返回一个FutureTask，然后执行FutureTask.get()方法或FutureTask.cancel（…）方法。除此以外，还可以单独使用FutureTask。
当一个线程需要等待另一个线程把某个任务执行完后它才能继续执行，此时可以使用FutureTask。假设有多个线程执行若干任务，每个任务最多只能被执行一次。当多个线程试图同时执行同一个任务时，只允许一个线程执行任务，其他线程需要等待这个任务执行完后才能继续执行。
下面是对应的示例代码。

private final ConcurrentMap<Object, Future<String>> taskCache = new ConcurrentHashMap<Object, Future<String>>();
private String executionTask(final String taskName) throws ExecutionException, InterruptedException {
	while (true) {
		Future<String> future = taskCache.get(taskName);　　// 1.1,2.1
		if (future == null) {
			Callable<String> task = new Callable<String>() {
				public String call() throws InterruptedException {
					return taskName;
				}
			}; // 1.2创建任务
			FutureTask<String> futureTask = new FutureTask<String>(task);
			future = taskCache.putIfAbsent(taskName, futureTask);　// 1.3
			if (future == null) {
				future = futureTask;
				futureTask.run();　　　　　　　　// 1.4执行任务
			}
		}
		try {
			return future.get();　　　　　　// 1.5,2.2线程在此等待任务执行完成
		} catch (CancellationException e) {
			taskCache.remove(taskName, future);
		}
	}
}

代码执行流程如下：

当两个线程试图同时执行同一个任务时，如果Thread 1执行1.3后Thread 2执行2.1，那么接下来Thread 2将在2.2等待，直到Thread 1执行完1.4后Thread 2才能从2.2（FutureTask.get()）返回。