前言：
创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。
这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。
如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。
而自从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果
1 Callable介绍
Callable 接口代表一段可以调用并返回结果的代码;Future接口表示异步任务，是还没有完成的任务给出的未来结果。所以说 Callable 用于产生结果， Future 用于获取结果。
Callable 接口使用泛型去定义它的返回类型。 Executors 类提供了一些有用的方法在线程池中执行 Callable 内的任务。由于 Callable 任务是并行的（并行就是整体看上去是并行的，其实在某个时间点只有一个线程在执行），我们必须等待它返回的结果。
java.util.concurrent.Future 对象为我们解决了这个问题。在线程池提交 Callable 任务后返回了一个 Future 对象，使用它可以知道 Callable 任务的状态和得到 Callable 返回的执行结果。 Future 提供了 get() 方法让我们可以等待 Callable 结束并获取它的执行结果。
2 Future介绍
2.1 在Future接口中声明方法
在Future接口中声明5种方法下面依次解释每个方法的作用：
2.2 Future提供了三种功能
1）判断任务是否完成； 2）能够中断任务； 3）能够获取任务执行结果。因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。
3 FutureTask
我们先来看一下FutureTask的实现：
public class FutureTask<V> implements RunnableFuture<V>
FutureTask 类实现了 RunnableFuture 接口，我们看一下 RunnableFuture 接口的实现：
|
1 2 3 |
public interface RunnableFuture<V> extends Runnable, Future<V> { void run(); } |
可以看出 RunnableFuture 继承了 Runnable 接口和 Future 接口，而 FutureTask 实现了 RunnableFuture 接口。所以它既可以作为Runnable被线程执行，又可以作为 Future 得到 Callable 的返回值。
FutureTask提供了2个构造器：
|
1 2 3 4 |
public FutureTask(Callable<V> callable) { } public FutureTask(Runnable runnable, V result) { } |
事实上， FutureTask 是 Future 接口的一个唯一实现类。
4 Future和FutureTask的使用
4.1 使用Callable+Future获取执行结果
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
public class CallableFutureTest {
public static void main(String[] args) { //创建线程池 ExecutorService es = Executors.newSingleThreadExecutor(); //创建Callable对象任务 CallableDemo calTask = new CallableDemo(); //提交任务并获取执行结果 Future<Integer> future = es.submit(calTask); //关闭线程池 es.shutdown(); try { Thread.sleep( 2000 ); System.out.println( "主线程在执行其他任务" );
if (future.get() != null ) { //输出获取到的结果 System.out.println( "future.get()-->" + future.get()); } else { //输出获取到的结果 System.out.println( "future.get()未获取到结果" ); }
} catch (Exception e) { e.printStackTrace(); } System.out.println( "主线程在执行完成" ); }
}
class CallableDemo implements Callable<Integer> {
private int sum;
@Override public Integer call() throws Exception { System.out.println( "Callable子线程开始计算啦！" ); Thread.sleep( 2000 );
for ( int i = 0 ; i < 100 ; i++) { sum = sum + i; } System.out.println( "Callable子线程计算结束！" ); return sum; } } |
Callable子线程开始计算啦！
Callable子线程计算结束！
主线程在执行其他任务
future.get()-->4950
主线程在执行完成
4.2 使用Callable+Future获取执行结果
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
public class CallableFutureTest {
public static void main(String[] args) { // //创建线程池 // ExecutorService es = Executors.newSingleThreadExecutor(); // //创建Callable对象任务 // CallableDemo calTask=new CallableDemo(); // //提交任务并获取执行结果 // Future<Integer> future =es.submit(calTask); // //关闭线程池 // es.shutdown();
//创建线程池 ExecutorService es = Executors.newSingleThreadExecutor(); //创建Callable对象任务 CallableDemo calTask = new CallableDemo(); //创建FutureTask FutureTask<Integer> futureTask = new FutureTask<>(calTask); //执行任务 es.submit(futureTask); //关闭线程池 es.shutdown(); try { Thread.sleep( 2000 ); System.out.println( "主线程在执行其他任务" );
if (futureTask.get() != null ) { //输出获取到的结果 System.out.println( "futureTask.get()-->" + futureTask.get()); } else { //输出获取到的结果 System.out.println( "futureTask.get()未获取到结果" ); }
} catch (Exception e) { e.printStackTrace(); } System.out.println( "主线程在执行完成" );
} }
class CallableDemo implements Callable<Integer> {
private int sum;
@Override public Integer call() throws Exception { System.out.println( "Callable子线程开始计算啦！" ); Thread.sleep( 2000 );
for ( int i = 0 ; i < 100 ; i++) { sum = sum + i; } System.out.println( "Callable子线程计算结束！" ); return sum; } } |
Callable子线程开始计算啦！
Callable子线程计算结束！
主线程在执行其他任务
futureTask.get()-->4950
主线程在执行完成
但其实这两种方法最终是一样的：
第一种方式 Callable+Future 最终也是以 Callable+FutureTask 的形式实现的。
在第一种方式中调用了： Future future = executor.submit(task);
那就让我们看看 executor.submit(task) 的源码吧：
|
1 2 3 4 5 6 7 8 9 10 11 |
//java.util.concurrent.AbstractExecutorService类中 /** * @throws RejectedExecutionException {@inheritDoc} * @throws NullPointerException {@inheritDoc} */ public <T> Future<T> submit(Callable<T> task) { if (task == null ) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task); //可以看到源码中其实是在submit(Callable<T> task)内部创建了一个RunnableFuture<T>接口实现类 execute(ftask); return ftask; } |
而 FutureTask 又是 RunnableFuture 的实现类，那就再看看 newTaskFor (Callable callable)里面干了什么：
|
1 2 3 |
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { return new FutureTask<T>(callable); } |
到此这篇关于 Java 多线程 Callable 、 Future 和 FutureTask 的文章就介绍到这了,更多相关 Java 多线程内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
原文链接：https://juejin.cn/post/7018051246279884836
查看更多关于Java多线程 Callable、Future 和FutureTask的详细内容...