Future和Callable
最后更新于：2022-08-12 11:16:47
Runnable的缺陷
1. 不能返回一个返回值
可以看到Runnable的run方法返回类型是void,所以我们在重写run方法的时候，是不会有返回值的。
2. 不能抛出checked Exception
异常只能通过try/catch来捕获，不能抛出。
如果强制抛出，会报错，因为Runnable的run方法没有声明抛出异常，所以我们重写的方法也不能抛出
Runnable为什么设计成这样
因为Runnable即便有返回值或者可以抛出异常，但是因为他的接收者是Thread,所以他的返回值或异常我们依然不能处理。我们唯一能处理的就是在run方法中
Callable接口
介绍
- 类似于Runnable，被其他线程执行的任务
- 实现call方法，就等于实现Runable接口，重写run方法一样
- 有返回值
源码
有返回值，返回值是泛型，同时有抛出异常
Future类
作用
一个方法的计算可能很耗时，在计算的过程中，没必要去一直处于等待，而使用子线程去执行，直到想要获取结果的时候，再用Future去控制等一系列动作，获取计算的结果，这样，计算过程归计算过程，而主要线程不必去一直等待。
Callable和Future的关系
我们可以通过Future.get来获取Callable接口返回的执行结果，还可以通过Future。isDone来判断任务是否已经执行完毕，以及取消这个任务，限时获取任务的结果等。
在call未执行完毕之前，调用get()的线程（假定此时是主线程）会被阻塞，直到call（）方法返回了结果后，此时future.get（）才会得到该结果，然后主线程才会切换到runnable状态
所以Future是一个存储器，它存储了call这个任务的结果，而这个任务的执行时间是无法提前确定的，因为这完全取决于call方法执行的情况
主要方法1：get()方法，获取结果
get方法的行为却决于Callable任务的状态，只有以下五种情况
- 任务正常完成：get会立刻返回结果
- 任务尚未完成（任务还没有开始或者进行中）：get将阻塞并直到任务完成
- 任务执行过程中抛出异常Exception:get方法会抛出ExecutionException:这里的抛出异常，是call（）执行时产生的那个异常，看到这个异常类型是Java.util.concurrent.ExecutionException。不论call()执行过程中抛出的异常类型是什么，最后get方法抛出的异常类型都是ExecutionException
- 任务被取消：get方法会抛出CancellationException
- 任务超时：get方法有一个重载方法，是传入一个延迟时间，如果时间到了还没有获取结果，get方法就会抛出TimeoutException
主要方法2：get(long timeout,TimeUnit unit) : 有超时的获取
- 用 get(long timeout,TimeUnit unit)方法时，如果call()在规定时间内完成了任务，那么就会正常获取到返回值，而如果在指定时间内没有计算出结果，那么就会抛出TimeoutException
- 超时不获取，任务需要取消
主要方法3： cancel方法，取消任务的执行
主要方法4： isDone()方法，判断线程是否执行完成
isDone方法会返回线程是否执行完毕，但是不会是否执行成功。即便执行失败了，也是执行完毕了。如果有中断产生，且以后也不会再执行了，也是执行完毕。
主要方法5： isCancelled()方法，判断线程是否被取消
用法1：线程池的submit方法返回Future对象，6个代码演示
首先。我们要给线程池提交我们的任务，提交时线程池会立刻返回给我们一个空的Future容器。当线程的任务一旦执行完毕，也就是当我们可以获取结果的时候，线程池便会把该结果填入到之前给我们的那个Future中去（而不是创建一个新的Future），我们此时便可以从该Future中获得任务执行的结果
get的基本用法
public class OneFuture {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(10);
Future<Integer> future = service.submit(new CallableTask());
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
service.shutdown();
}
static class CallableTask implements Callable<Integer> {
@Override
public Integer call() throws Exception {
Thread.sleep(3000);
return new Random().nextInt();
}
}
}Callable的lambda表达式形式
public class OneFutureLambda {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(10);
Future<Integer> future = service.submit(() -> {
Thread.sleep(3000);
return new Random().nextInt();
});
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
service.shutdown();
}
}
多个任务，用Future数组来获取结果
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(2);
ArrayList<Future> futures = new ArrayList<>();
for (int i = 0; i < 6; i++) {
Future<Integer> future = service.submit(() -> {
Thread.sleep(3000);
return new Random().nextInt();
});
futures.add(future);
}
for (Future f : futures) {
try {
System.out.println(f.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
service.shutdown();
}
任务执行过程中抛出Exception和isDone展示
异常执行时就已经产生，但是只有在调用get方法的时候才会抛出,有没有异常，不导致isdone获得的结果
public class GetException {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(20);
Future<Integer> future = service.submit(() -> {
throw new IllegalArgumentException("Callable 抛出异常");
});
try {
for (int i = 0; i < 5; i++) {
System.out.println(i);
Thread.sleep(500);
}
System.out.println(future.isDone());
future.get();
} catch (InterruptedException e) {
System.out.println(e.getMessage());
System.out.println("InterruptedException异常");
} catch (ExecutionException e) {
System.out.println(e.getMessage());
System.out.println("ExecutionException");
}
service.shutdown();
}
}0
1
2
3
4
true
java.lang.IllegalArgumentException: Callable 抛出异常
ExecutionException获取任务的超时
需要注意超时后的处理，需要调用future.cancel()。
public class TimeOut {
private static final Ad DEFAULT_AD = new Ad("默认的广告");
private static final ExecutorService exec = Executors.newFixedThreadPool(1);
static class Ad {
String name;
public Ad(String name) {
this.name = name;
}
@Override
public String toString() {
return "Ad{" +
"name='" + name + '\'' +
'}';
}
}
static class FetchAdTask implements Callable<Ad> {
@Override
public Ad call() throws Exception {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
System.out.println("sleep期间被中断");
return new Ad("被中断时候的默认广告");
}
return new Ad("一个真实的广告");
}
}
private void printAd() {
Future<Ad> adFuture = exec.submit(new FetchAdTask());
Ad ad = null;
try {
ad = adFuture.get(4, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} catch (TimeoutException e) {
ad = new Ad("被中断的默认广告");
System.out.println("超时，未获取到广告");
boolean cancel = adFuture.cancel(false);
System.out.println("cancel的结果" + cancel);
}
exec.shutdown();
System.out.println(ad);
}
public static void main(String[] args) {
TimeOut timeOut = new TimeOut();
timeOut.printAd();
}
}
正常的结果
Ad{name='一个真实的广告'}超时时间改为2S： ad = adFuture.get(2, TimeUnit.SECONDS);
超时，未获取到广告
cancel的结果true
Ad{name='被中断的默认广告'}取消的参数改为true：adFuture.cancel(true);
传入true,代表如果任务正在执行中，那么就把线程中断掉。因为在java中，线程的停止不是强制的，而是一种商量的模式。当线程想要被停止的时候，会收到一个InterruptedException异常，而是否停止或者多久停止，完全由自己控制。
超时，未获取到广告
cancel的结果true
sleep期间被中断
Ad{name='被中断的默认广告'}cancel方法的结果
- 如果这个任务还没有开始执行，那么这种情况最简单，任务会被正常的取消，未来也不会被执行，方法返回true
- 如果任务已完成，或者已经取消：那么cancel()方法会执行失败，方法返回false
- 如果任务已经开始执行了，那么这个取消方法将不会直接取消该任务，而是会根据我们填的参数mayInterruptIfRunning做判断。如果是true，任务就会收到中断信号，false则不会
Future.cancel(true)适用于：
- 任务能够处理interrupt
Future.cancel(false)适用于：
- 未能处理interrupt的任务
- 不清楚任务是否支持取消
- 需要等待已经开始的任务执行完成
用法2：用TutureTask来创建Future
把Callable实例当作参数，生成FutureTask的对象，然后把这个对象当作一个Runnable对象，用线程池或另起线程去执行这个Runnable对象，最后通过FutureTask获取刚才执行的结果
public class FutureTaskDemo {
public static void main(String[] args) {
Task task = new Task();
FutureTask<Integer> futureTask = new FutureTask<>(task);
Thread thread = new Thread(futureTask);
thread.start();
// 也可以使用线程池来处理
// ExecutorService service = Executors.newCachedThreadPool();
// service.submit(futureTask);
try {
Integer integer = futureTask.get();
System.out.println("允许结果" + integer);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
class Task implements Callable<Integer> {
@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;
}
}
结果
子线程正在计算
运行结果4950Future的注意点
- 当for循环批量获取future的结果时，容易发生一部分线程很慢的情况，get方法调用时应使用timeout限制
- Future的生命周期不能后退，生命周期只能前进，不能后退。就和线程池的生命周期一样，一旦完成了任务，他就永久地停在了已完成的状态，不能重头再来