在这篇文章中，我们将看看如何ExeutorService使用 来运行多线程异步任务。我们将从直接创建线程开始，然后继续探索它ExeutorService以及如何使用它来简化事情。
直接创建线程
在 Executor API 出现之前，开发人员负责直接实例化和管理线程。下面我们来看一个简单的例子。
/**
* Call 2 expensive methods on separate threads
*
* @throws InterruptedException
*/
public void doMultiThreadedWork() throws InterruptedException {
/* create Runnable using anonymous inner class */
Thread t1 = new Thread(new Runnable() {
public void run() {
System.out.println("starting expensive task thread t1");
doSomethingExpensive();
System.out.println("finished expensive task thread t1");
}
});
/* start processing on new threads */
t1.start();
/* block current thread until t1 has finished */
t1.join();
}在上面的方法中，我们创建了一个新的Threadt1 并将 a 传递Runnable给它的构造函数。匿名内部类实现Runnable其中run()方法包含线程启动时将执行的逻辑。注意，如果里面的代码run()抛出了一个checked Exception，它必须在方法内部被捕获和处理。
介绍 Executor 服务
直接处理线程可能很麻烦，因此 Oracle 通过其 Executor API 提供一个抽象层来简化事情。AnExecutor允许您异步处理任务，而无需直接处理线程。
创建一个执行器
该Executors工厂类用于创建的实例Executor，无论是一个ExecutorService或一个 ScheduledExecutorService。Executor下面描述了一些最常见的类型。
Executors.newCachedThreadPool()—ExecutorService具有线程池的线程池，可根据需要创建新线程，但在可用时重用先前创建的线程。Executors.newFixedThreadPool(int numThreads)—ExecutorService具有固定线程数的线程池。该numThreads参数是ExecutorService在任一时间可以处于活动状态的最大线程数。如果提交到池中的请求数量超过池大小，则请求将排队等待线程变为可用。Executors.newScheduledThreadPool(int numThreads)—ScheduledExecutorService具有用于定期或在指定延迟后运行任务的线程池的A。Executors.newSingleThreadExecutor()—ExecutorService单线程。提交的任务将按提交的顺序一次执行一项。Executors.newSingleThreadScheduledExecutor()—ExecutorService使用单个线程定期或在指定延迟后执行任务的一种。
下面的代码片段创建了ExecutorService一个池大小为 2的固定线程池。我将ExecutorService在接下来的部分中使用它。
ExecutorService executorService = Executors.newFixedThreadPool(2);
在以下部分中，我们将了解如何ExecutorService使用它来创建和管理异步任务。
执行（可运行）
当您想要运行任务并且不关心检查其状态或获取结果时，该execute方法采用 aRunnable和非常有用。把它想象成火而忘记异步任务。
executorService.execute(()->{
System.out.println(String.format("starting expensive task thread %s", Thread.currentThread().getName()));
doSomethingExpensive();
}与使用匿名内部类的第一个 Thread 示例不同，上面的示例Runnable使用 lambda 表达式创建。该Runnable将尽快执行一个线程可以从ExecutorService线程池。
Future<?> 提交（可运行）
就像execute()，该submit()方法也接受 aRunnable但不同于execute()因为它返回 a Future。AFuture是一个对象，表示来自异步任务的挂起响应。将其视为可用于检查任务状态或在任务完成时检索其结果的句柄。Futures 使用泛型来允许您指定任务的返回类型。然而，鉴于该Runnablerun()方法的返回类型为 void，它Future保存了任务的状态而不是挂起的结果。这Future<?>在下面的示例中表示。
Future<?> taskStatus = executorService.submit(()->{
System.out.println(String.format("starting expensive task thread %s", Thread.currentThread().getName()));
doSomethingExpensive();
}在submit(Runnable)当你想运行一个不返回值的任务，但你想，它已经提交后检查任务的状态的方法是有用的ExecutorService。
检查任务状态
Future有一些有用的方法来检查已提交到ExecutorService.
isCancelled()检查提交的任务是否已经被取消。isDone()检查提交的任务是否已经完成。当任务完成时，isDone无论任务成功完成、失败还是被取消， 都将返回 true。cancel()取消提交的任务。一个布尔参数指定如果任务已经开始，是否应该中断它。
/* check if both tasks have completed - if not sleep current thread
* for 1 second and check again
*/
while(!task1Future.isDone() || !task2Future.isDone()){
System.out.println("Task 1 and Task 2 are not yet complete....sleeping");
Thread.sleep(1000);
}Future<T> 提交（可调用）
该submit方法被重载以采用 aCallable和 a Runnable。与 a 一样Runnable， aCallable表示在另一个线程上执行的任务。ACallable与 a 不同，Runable因为它返回一个值并且可以抛出一个已检查的异常。该Callable接口具有单个抽象方法，public T call() throws Exception并且Runable可以使用匿名内部类或 lambda 来实现。所述的返回类型call()方法用于键入Future被返回ExecutorService。下面的两个代码片段展示了如何Callable通过匿名内部类和 lambda 表达式创建 a。
Future<Double> task1Future = executorService.submit(new Callable<Double>() {
public Double call() throws Exception {
System.out.println(String.format("starting expensive task thread %s",
Thread.currentThread().getName()));
Double returnedValue = someExpensiveRemoteCall();
return returnedValue;
}
});Future<Double> task2Future = executorService.submit(()->{
System.out.println(String.format("starting expensive task thread %s", Thread.currentThread().getName()));
Double returnedValue = someExpensiveRemoteCall();
return returnedValue;
});这两个示例都创建了一个Callable并将其传递给execute方法。的Callable是只要一个线程可用来执行。
从未来得到结果
当 aCallable提交到 时ExecutorService，我们会收到Future带有call()方法返回类型的a 。在上面的例子中，call()返回 aDouble所以我们得到 a Future<Double>。从 a 检索结果的一种方法Future是调用它的get()方法。get()将无限期阻塞等待提交的任务完成。如果任务没有完成或需要很长时间才能完成，主应用程序线程将保持阻塞状态。
无限期地等待结果通常并不理想。如果任务没有在一定时间内完成，我们宁愿对如何检索结果有更多的控制权，并采取一些行动。幸运的是，有一个重载get(long timeout, TimeUnit unit)方法会等待指定的时间段，如果任务尚未完成（结果不可用），则会抛出一个TimeoutException.
Double value1 = task1Future.get();
Double value2 = task2Future.get(4, TimeUnit.SECONDS); // throws TimeoutException提交多个 Callables
除了允许你提交一个的Callable，则ExecutorService允许你提交Collection的Callable使用invokeAll方法。正如您所料，返回的是Futurea Collectionof Futures而不是返回单个。Future返回A表示每个提交任务的挂起结果。
Collection<Callable<Double>> callables = new ArrayList<>();
IntStream.rangeClosed(1, 8).forEach(i-> {
callables.add(createCallable());
});
/* invoke all supplied Callables */
List<Future<Double>> taskFutureList = executorService.invokeAll(callables);
/* call get on Futures to retrieve result when it becomes available.
* If specified period elapses before result is returned a TimeoutException
* is thrown
*/
for (Future<Double> future : taskFutureList) {
/* get Double result from Future when it becomes available */
Double value = future.get(4, TimeUnit.SECONDS);
System.out.println(String.format("TaskFuture returned value %s", value));
}上面的代码片段将 8 提交Callable给ExecutorService并检索List包含 8 Future。Future返回的列表与Callable提交的s 的顺序相同。请注意，Callable如果我们希望大多数或所有提交的任务可以并行执行，提交多个s 将需要调整线程池的大小。在上面的例子中，我们需要一个有 8 个线程的线程池来并行运行所有任务。
关闭 ExecutorService
在所有任务完成后，重要的是正常关闭，ExecutorService以便可以回收使用的资源。有两种方法可用，shutDown()和shutDownNow()。shutDown()触发 关闭ExecutorService，允许当前处理的任务完成但拒绝新提交的任务。
shutDownNow()也会触发 的关闭ExecutorService，但不允许当前正在执行的任务完成并尝试立即终止它们。shutDownNow()返回启动关闭时排队等待执行的任务列表。为了确保ExecutorService在所有情况下都关闭并避免潜在的资源泄漏，重要的是在 块内调用 shutDown()或。shutDownNow()finally
ExecutorService executorService = null;
try{
executorService = Executors.newFixedThreadPool(2);
executorService.execute(()->{
System.out.println(String.format("starting expensive task thread %s", Thread.currentThread().getName()));
doSomethingExpensive();
});
}
finally{
executorService.shutdown();
}总结
在这篇文章中，我们研究ExecutorService了它以及如何使用它来简化异步任务的创建和管理。这篇文章随附的源代码可在GitHub上找到，所以为什么不拉取代码并尝试一下。与往常一样，请随时在下面发表评论或问题。