Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！

使用Executors类来创建线程池。

---

通过执行器你无需自己创建与控制Thread对象。比如，你不用在代码中编写new Thread或者thread1.start()也一样可以使用多线程。如下例:

ExecutorService exec = Executors.newCachedThreadPool();

for (int i = 0; i < 5; i++) { //5个任务

exec.submit(new Runnable() {

@Override

public void run() {

System.out.println(Thread.currentThread().getName()+" doing task");

}

});

}

exec.shutdown(); //关闭线程池

输出如下:

pool-1-thread-2 doing task

pool-1-thread-1 doing task

pool-1-thread-3 doing task

pool-1-thread-4 doing task

pool-1-thread-5 doing task

从输出我们可以看到，exec使用了线程池1中的5个线程做了这几个任务。

这个例子中exec这个Executor负责线程管理任务，所谓的任务在这里就是实现了Runnable接口的匿名类。至于要使用几个线程，什么时候启动这些线程，是用线程池还是用单个线程来完成这些任务，我们无需操心。完全由exec这个执行器来负责。在这里exec(newCachedThreadPool)指向是一个可以根据需求创建新线程的线程池。

Executors相当于执行器的工厂类，包含各种常用执行器的静态工厂方法，可以直接创建常用的执行器。几种常用的执行器如下：

Executors.newCachedThreadPool,根据需要可以创建新线程的线程池。线程池中曾经创建的线程，在完成某个任务后也许会被用来完成另外一项任务。

Executors.newFixedThreadPool(int nThreads) ,创建一个可重用固定线程数的线程池。这个线程池里最多包含nThread个线程。起到限制并发线程数的作用。

Executors.newSingleThreadExecutor() ,创建一个使用单个 worker 线程的 Executor。即使任务再多，也只用1个线程完成任务。会顺序执行提交的任务。

Executors.newSingleThreadScheduledExecutor() ,创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期执行。

newSingleThreadExecutor例子如下：

ExecutorService exec = Executors.newSingleThreadExecutor();

for (int i = 0; i < 5; i++) {

exec.execute(new Runnable() {//execute方法接收Runnable对象，无返回值

@Override

public void run() {

System.out.println(Thread.currentThread().getName());

}

});

}

exec.shutdown();

输出如下：

pool-1-thread-1

pool-1-thread-1

pool-1-thread-1

pool-1-thread-1

pool-1-thread-1

可以看出，虽然有5个任务(5个new Runnable)，但是只由1个线程来完成。

**最佳实践：**我们应直接使用现有Executors的静态工厂方法生成所需的线程池，然后利用线程池来执行任务，而不要自己创建线程。

Executor与ExecutorService的常用方法

---

execute方法

Executor接口只有void execute(Runnable command)方法。从方法声明中可以看到入参为Runnable类型。常用例子如下:

Executor executor = anExecutor;

executor.execute(new RunnableTask1());

但里面具体怎么执行，是否调用线程则由相应的Executor接口实现类决定。比如，前面的newCachedThreadPool使用线程池来进行执行。

可以看出，Executor将任务提交与每个任务如何运行(如何使用线程、调度)相分离。

submit方法

ExecutorService接口继承自Executor接口，扩展了父接口中的execute方法。有两个常用的submit方法

Future<?> submit(Runnable task)

Future submit(Callable task)

可以看到，这两个常用方法一个接收Runnable类型入参，一个接收Callable类型入参。

Callable入参允许任务返回值，而Runnable无返回值。

也就是说如果我们希望线程有一个返回结果，我们应该使用Callable类型入参。

invokeAll与invokeAny方法

批量执行一组Callable任务。

invokeAll是等所有任务完成后，返回代表结果的Future列表。

invokeAny是等一批任务中的任何一个任务完成后就返回。

从两个方法的返回结果我们也可以看出两个方法的不同：

List<Future> invokeAll(Collection<? extends Callable> tasks)

T invokeAny(Collection<? extends Callable> tasks)

invokeAll返回的是List，而invoke返回的是T。

shutdown()方法

启动一次顺序关闭，执行以前提交的任务，但不接受新任务。

执行此方法后，线程池等待任务结束后就关闭，同时不再接收新的任务。

如果执行完shutdown()方法后，再去执行execute方法则直接抛出RejectedExecutionException。

不要问我为什么知道…刚从坑里爬出来。

原则：只要ExecutorService(线程池)不再使用，就应该关闭，以回收资源。要注意这个不再使用。

上述方法较多，可以配合后面的实例进行理解。可以先记住execute方法与shutdown方法。

3. Callable与Future

===================

Callable接口

---

Runnable接口中的public void run()方法无返回值，如果我们希望线程运算后将结果返回，使用Runnable就无能为力。

这时我们应使用Callable接口。**Callable代表有返回值的任务。**一个实现Callable接口的类如下所示：

class CalcTask implements Callable {

@Override

public String call() throws Exception {

return Thread.currentThread().getName();

}

}

这个任务比较简单，就是返回当前线程的名字。与Runnable相比较有一个返回值，此例中返回值类型为String。

使用如下代码进行调用：

ExecutorService exec = Executors.newCachedThreadPool();

List<Callable> taskList = new ArrayList<>();

/* 往任务列表中添加5个任务 */

for (int i = 0; i < 5; i++) {

taskList.add(new CalcTask()); // CalcTask为实现Callable接口的类，有返回值。

}

/* 结果列表:存放任务完成返回的值 */

List<Future> resultList = new ArrayList<>(); // Future用来存放任务返回值，T为返回值得类型

try {

/invokeAll批量运行所有任务。submit提交单个任务/

resultList = exec.invokeAll(taskList);

} catch (InterruptedException e) {

e.printStackTrace();

}

try {

/从future中输出每个任务的返回值/

for (Future future : resultList) {

System.out.println(future.get()); // get方法会阻塞直到结果返回。返回值类型为String

}

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

输出如下:

pool-1-thread-1

pool-1-thread-2

pool-1-thread-3

pool-1-thread-4

pool-1-thread-5

Future接口

---

上面的例子中使用了Future接口。Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。

上面的例子中exec执行器执行了一个Callable类型的任务列表然后得到了Futuer类型的结果列表resultList。

Future.get方法

等待计算完成，然后获取其结果。

Future.isDone方法

用来查询任务是否做完。

例子如下：

/新建一个Callable任务/

Callable callableTask = new Callable<>() {

@Override

public Integer call() throws Exception {

System.out.println(“Calculating 1+1!”);

TimeUnit.SECONDS.sleep(2);//休眠2秒

return 2;

}

};

ExecutorService executor = Executors.newCachedThreadPool();

Future result = executor.submit(callableTask);

executor.shutdown();

while(!result.isDone()){ // isDone()方法可以查询子线程是否做完

System.out.println(“子线程正在执行”);

TimeUnit.SECONDS.sleep(1); // 休眠1秒

}

try {

System.out.println(“子线程执行结果:”+result.get());

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

输出如下：

Calculating 1+1!

子线程正在执行

子线程正在执行

子线程执行结果:2

4.FutureTask

============

FutureTask类是 Future 接口的一个实现。FutureTask类实现了RunnableFuture接口，RunnableFuture继承了Runnable接口和Future接口，所以：

1. FutureTask可以作为Runnable被线程执行

面试结束复盘查漏补缺

每次面试都是检验自己知识与技术实力的一次机会，面试结束后建议大家及时总结复盘，查漏补缺，然后有针对性地进行学习，既能提高下一场面试的成功概率，还能增加自己的技术知识栈储备，可谓是一举两得。

以下最新总结的阿里P6资深Java必考题范围和答案，包含最全MySQL、Redis、Java并发编程等等面试题和答案，用于参考~

重要的事说三遍，关注+关注+关注！

更多笔记分享

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！

1. FutureTask可以作为Runnable被线程执行

面试结束复盘查漏补缺

每次面试都是检验自己知识与技术实力的一次机会，面试结束后建议大家及时总结复盘，查漏补缺，然后有针对性地进行学习，既能提高下一场面试的成功概率，还能增加自己的技术知识栈储备，可谓是一举两得。

以下最新总结的阿里P6资深Java必考题范围和答案，包含最全MySQL、Redis、Java并发编程等等面试题和答案，用于参考~

重要的事说三遍，关注+关注+关注！

[外链图片转存中…(img-o2AhFcxq-1714682760875)]

[外链图片转存中…(img-TzGq1fh1-1714682760875)]

更多笔记分享

[外链图片转存中…(img-wUR0SfjY-1714682760876)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！