Callable接口和Future
Callable 的概述
Callable接口是java SE5 在java.util.concurrent 引入的一个泛型接口，它只有一个名为call()的方法，该方法可以抛出任何异常并且返回一个值。定义一个Callable接口的实例，可以提交给Executor框架的submit()方法，该方法将返回一个Future对象，通过这个Future对象我们可以获取计算结果或取消任务
Callable 的使用
使用Callable接口的关键步骤如下：
- 创建一个类并实现Callable接口，同时也需要实现call方法
- new FutureTask对象，传递一个实现Callable接口的类作为构造函数
- 用Thread进行实例化，传入实现Runnabnle接口的FutureTask的类
- 最后通过 futureTask.get() 获取到返回值
示例代码如下
//1 --- 创建类并实现Callable接口
public class CallableDemo implements Callable<String> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
//实现Call方法
@Override
public String call() throws Exception {
System.out.println();
return Thread.currentThread().getName();
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
//new FutureTask对象，传递一个实现Callable接口的类作为构造函数
FutureTask task = new FutureTask(new CallableDemo());
//用Thread进行实例化，传入实现Runnabnle接口的FutureTask的类
new Thread(task,"A").start();
//最后通过 task.get() 获取到返回值
String threadName = task.get();
System.out.println("通过调用Callabled的线程名称是："+ threadName);
}
}
执行代码，输出结果：
A
Process finished with exit code 0
注意：
- 要求获得Callable线程的计算结果，如果没有计算完成就要去获取，会导致阻塞，直到计算完成
2. 多个线程执行 一个FutureTask的时候，只会计算一次
3.如果我们要两个线程同时计算任务的话，那么需要这样写，需要定义两个futureTask
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @ClassName CallDemo
* @Description CallDemo
* @Author Avgrado
* @Date 2023-11-06 14:43
*/
public class CallableDemo implements Callable<String> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
@Override
public String call() throws Exception {
System.out.println("调用了Call方法");
return Thread.currentThread().getName();
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask task1 = new FutureTask(new CallableDemo());
FutureTask task2 = new FutureTask(new CallableDemo());
new Thread(task1,"aa").start();
new Thread(task2,"bb").start();
System.out.println("获取到的结果"+task1.get());
System.out.println("获取到的结果"+task2.get());
}
}
输出结果：
Future的概述
Future接口是Java的并发包(java.util.concurrent)中的一个重要接口，它代表了一个异步计算的结果。Future接口的主要作用是允许程序在异步计算完成之前可以继续执行其他任务，而不需要等待计算完成。
Future接口提供了一些方法来检查计算是否完成、获取计算结果以及取消计算任务。其中最重要的方法是get()方法，它用于获取计算结果。如果计算未完成，get()方法会阻塞等待直到计算完成。如果计算已经完成，那么get()方法会立即返回计算结果。
Future 接口的方法
package java.util.concurrent;
public interface Future<V> {
/**
* 取消任务，取消任务成功则返回true，失败则返回false
*/
boolean cancel(boolean mayInterruptIfRunning);
/**
* 判断任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true
*/
boolean isCancelled();
/**
* 判断任务是否已经完成，若任务完成，则返回true
*/
boolean isDone();
/**
* 获取执行结果，调用这个方法获取结果时，如果任务结果还没有计算完成会导致产生阻塞，会一直等到任务执行完毕才返回
*/
V get() throws InterruptedException, ExecutionException;
/**
* 在一定的阻塞时间内获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null
*/
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
Future的实现类 FutureTask
FutureTask 位于java.util.concurrent 包下，是一个可取消的异步计算任务 其结构图如下：
从结构图来看：FutureTask实现了 Runnable 和 Future接口，并方便地将两种功能组合在一起，可以获取执行结果。并且通过构造函数提供Callable来创建FutureTask，适用于那些需要异步计算，并且希望在某个时间点获取结果的场景。它允许你暂停、恢复和取消一个任务。FutureTask的状态包括：
- PENDING（等待任务开始）
- RUNNING（任务正在运行）
- DONE（任务已完成）
FutureTask 适用于执行比较耗时的操作且不能影响主线程的执行，此时可以用FutureTask 去处理耗时的任务，后续通过调用 FutureTask的 isDone() 方法去判断任务是否执行完成，待到任务执行完成后再通过 get() 方法去获取任务结果
需要注意的点：
- 在计算完成后才能获取到结果，否则调用get方法会阻塞
- 计算完成之后就不能重新计算或者取消计算
Futrue 接口的使用
下面是使用Future接口的例子
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableDemo {
public static void main(String[] args) {
//创建线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
// 模拟耗时操作
Thread.sleep(1000);
return "Hello, World!";
}
});
executorService.shutdown(); // 关闭线程池，不执行未提交的任务
try {
// 获取任务执行结果，如果任务未完成，会阻塞等待
String result = future.get();
System.out.println(result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
FutureTask开启异步任务
public class FutureDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> futureTask = new FutureTask(new MyThread());
Thread t1 = new Thread(futureTask); //开启一个异步线程
t1.start();
System.out.println(futureTask.get()); //有返回hello Callable
}
}
class MyThread implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("--------come in");
return "hello Callable";
}
}
Future编码实战和优缺点分析
- 优点：Future+线程池异步多线程任务配合，能显著提高程序的运行效率。
- 缺点：
- get()阻塞---一旦调用get()方法求结果，一旦调用不见不散，非要等到结果才会离开，不管你是否计算完成，如果没有计算完成容易程序堵塞。
- isDone()轮询---轮询的方式会耗费无谓的cpu资源，而且也不见得能及时得到计算结果，如果想要异步获取结果，通常会以轮询的方式去获取结果，尽量不要阻塞。
- 结论：Future对于结果的获取不是很友好，只能通过阻塞或轮询的方式得到任务的结果
Future获取结果get()和轮询
public class FutureDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> task = new FutureTask<>(()->{
System.out.println(Thread.currentThread().getName() + "--------come in");
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "task over";
});
Thread t = new Thread(task);
t.start();
System.out.println(Thread.currentThread().getName()+"--------忙其他任务");
while(true){
if(task.isDone()){
System.out.println(task.get());
break;
}else{
TimeUnit.MILLISECONDS.sleep(500);
System.out.println("正在处理中，不要催！ 越催越慢，再催熄火！");
}
}
}
执行结果如下
main--------忙其他任务
Thread-0--------come in
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
正在处理中，不要催！ 越催越慢，再催熄火！
task over
Process finished with exit code 0
