Java 并发编程:Callable、Future 和 FutureTask
Java 并发编程:Callable、Future 和 FutureTask
在前面的文章中我们讲述了创建线程的 2 种方式,一种是直接继承 Thread,另外一种就是实现 Runnable 接口。
这 2 种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果。
如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦。
而自从 Java 1.5 开始,就提供了 Callable 和 Future,通过它们可以在任务执行完毕之后得到任务执行结果。
今天我们就来讨论一下 Callable、Future 和 FutureTask 三个类的使用方法。以下是本文的目录大纲:
一. Callable 与 Runnable
二. Future
三. FutureTask
四. 使用示例
若有不正之处请多多谅解,并欢迎批评指正。
请尊重作者劳动成果,转载请标明原文链接:
一. Callable 与 Runnable
先说一下 java.lang.Runnable 吧,它是一个接口,在它里面只声明了一个 run() 方法:
public interface Runnable {
public abstract void run();
}
由于 run() 方法返回值为 void 类型,所以在执行完任务之后无法返回任何结果。
Callable 位于 java.util.concurrent 包下,它也是一个接口,在它里面也只声明了一个方法,只不过这个方法叫做 call():
public interface Callable {
/**
* 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;
}
可以看到,这是一个泛型接口,call() 函数返回的类型就是传递进来的 V 类型。
那么怎么使用 Callable 呢?一般情况下是配合 ExecutorService 来使用的,在 ExecutorService 接口中声明了若干个 submit 方法的重载版本:
Future submit(Callable task);
Future submit(Runnable task, T result);
Future submit(Runnable task);
第一个 submit 方法里面的参数类型就是 Callable。
暂时只需要知道 Callable 一般是和 ExecutorService 配合来使用的,具体的使用方法讲在后面讲述。
一般情况下我们使用第一个 submit 方法和第三个 submit 方法,第二个 submit 方法很少使用。
二. Future
Future 就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get 方法获取执行结果,该方法会阻塞直到任务返回结果。
Future 类位于 java.util.concurrent 包下,它是一个接口:
public interface Future {
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,此方法肯定返回 false,即如果取消已经完成的任务会返回 false;如果任务正在执行,若 mayInterruptIfRunning 设置为 true,则返回 true,若 mayInterruptIfRunning 设置为 false,则返回 false;如果任务还没有执行,则无论 mayInterruptIfRunning 为 true 还是 false,肯定返回 true。
isCancelled 方法表示任务是否被取消成功,如果在任务正常完成前被取消成功,则返回 true。
isDone 方法表示任务是否已经完成,若任务完成,则返回 true;
get() 方法用来获取执行结果,这个方法会产生阻塞,会一直等到任务执行完毕才返回;
get(long timeout, TimeUnit unit) 用来获取执行结果,如果在指定时间内,还没获取到结果,就直接返回 null。
也就是说 Future 提供了三种功能:
1)判断任务是否完成;
2)能够中断任务;
3)能够获取任务执行结果。
因为 Future 只是一个接口,所以是无法直接用来创建对象使用的,因此就有了下面的 FutureTask。
三. FutureTask
我们先来看一下 FutureTask 的实现:
public class FutureTask implements RunnableFuture
FutureTask 类实现了 RunnableFuture 接口,我们看一下 RunnableFuture 接口的实现:
public interface RunnableFuture extends Runnable, Future {
void run();
}
可以看出 RunnableFuture 继承了 Runnable 接口和 Future 接口,而 FutureTask 实现了 RunnableFuture 接口。所以它既可以作为 Runnable 被线程执行,又可以作为 Future 得到 Callable 的返回值。
FutureTask 提供了 2 个构造器:
public FutureTask(Callable callable) {
}
public FutureTask(Runnable runnable, V result) {
}
事实上,FutureTask 是 Future 接口的一个唯一实现类。
四. 使用示例
1. 使用 Callable+Future 获取执行结果
public class Test {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
Future result = executor.submit(task);
executor.shutdown();
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System.out.println("主线程在执行任务");
try {
System.out.println("task运行结果"+result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("所有任务执行完毕");
}
}
class Task implements Callable{
@Override
public Integer call() throws Exception {
System.out.println("子线程在进行计算");
Thread.sleep(3000);
int sum = 0;
for(int i=0;i<100;i++)
sum += i;
return sum;
}
}
执行结果:
子线程在进行计算
主线程在执行任务
task运行结果4950
所有任务执行完毕
View Code
2. 使用 Callable+FutureTask 获取执行结果
public class Test {
public static void main(String[] args) {
//第一种方式
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
//由callable创建FutureTask
FutureTask futureTask = new FutureTask(task);
//executor可以submit callable和runnable类型的对象使其执行,Thread类的不能使用线程池,只能调用start方法自己执行
executor.submit(futureTask);
executor.shutdown();
//第二种方式,注意这种方式和第一种方式效果是类似的,只不过一个使用的是ExecutorService,一个使用的是Thread
/*Task task = new Task();
FutureTask futureTask = new FutureTask(task);
Thread thread = new Thread(futureTask);
thread.start();*/
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System.out.println("主线程在执行任务");
try {
System.out.println("task运行结果"+futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("所有任务执行完毕");
}
}
class Task implements Callable{
@Override
public Integer call() throws Exception {
System.out.println("子线程在进行计算");
Thread.sleep(3000);
int sum = 0;
for(int i=0;i<100;i++)
sum += i;
return sum;
}
}
如果为了可取消性而使用 Future 但又不提供可用的结果,则可以声明 Future> 形式类型、并返回 null 作为底层任务的结果。
package com.jiading;
import java.util.concurrent.*;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService pool= Executors.newFixedThreadPool(2);
Callable c1=new MyCallable("A");
Callable c2=new MyCallable("B");
//执行任务并获取Future对象
// 使用线程池,直接调用pool的Submit方法即可创建线程
/**
* 注意,Future只是一个接口,它有一个唯一的实现类是FutureTask,所以这里声明FutureTask也行
* System.out.println(f1.getClass().toString());的执行结果就是class java.util.concurrent.FutureTask
*/
Future f1=pool.submit(c1);
Future f2=pool.submit(c2);
//注意,获取FutureTask对象的时候,线程可能还没有执行完
//FutureTask对象的get方法会阻塞至线程执行完成
//从FutureTask对象上获取任务的返回值
System.out.println(">>>"+f1.get().toString());
System.out.println(">>>"+f2.get().toString());
System.out.println(f1.getClass().toString());
pool.shutdown();
}
}