共计 2411 个字符,预计需要花费 7 分钟才能阅读完成。
Callable,Future 与 FutureTask
作用
通过实现 Callable 接口同样可能创立一个线程,但与 Runnable 接口不同的是 Callable 接口有返回值。
Callable 接口
JDK 源码 :
@FunctionalInterface
public interface Callable<V> {V call() throws Exception;
}
能够看出,与 Runnable 同样属于一个接口办法,但两者不同的是,Callable 接口有返回值且反对泛型。
应用
Callable 的应用个别是配置线程池 ExecutorService 来应用。其能够通过一个 submit() 办法来让一个 Callable 接口执行,返回一个 Future。通过 Future 的 get 办法能够取得后果。
案例 :
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Demo03 {public static void main(String[] args) throws InterruptedException, ExecutionException {
// 创立一个线程池
ExecutorService es=Executors.newCachedThreadPool();
// 创立线程对象
MyThread mt=new MyThread();
// 应用 Future
Future<Integer> fu=es.submit(mt);
// 通过 get 办法取得返回值
System.out.println(fu.get());
}
}
class MyThread implements Callable<Integer>{
@Override
public Integer call() throws Exception {
// TODO Auto-generated method stub
Thread.sleep(1000);
return 2;
}
}
get 办法调用后会阻塞以后线程,理论应用时倡议重写 get 办法,应用能够设置超时工夫的重载 get 办法。
Future 接口
JDK 源码 :
public interface Future<V> {boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
其中 cancel 办法是试图勾销一个线程的执行。
cancel 并不一定能勾销线程的执行,因为一个工作可能已实现,已勾销或者一些其它起因,存在勾销失败的可能。
返回值 boolean,当勾销胜利返回 true,失败返回 false。
参数 mayInterruptIfRunning,示意是否应用中断的形式勾销线程执行。
所以有时候,为了让工作有可能勾销的性能,就使⽤ Callable 来代替 Runnable。
如果为了可勾销性⽽使⽤ Future 但⼜不提供可⽤的后果,则能够申明 Future<?> 模式类型、并返回 null 作为底层工作的后果。
FutureTask 类
JDK 源码 :
public interface RunnableFuture<V> extends Runnable, Future<V>
FutureTask 实现了 RunnableFuture 接口,而 RunnableFuture 接口则继承了 Runnable 接口与 Future 接口。
FutureTask 类相当于是一个工具类,应用它咱们不必本人去实现 Future 接口中那些简单的形象办法。
案例 :
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class Demo04 {public static void main(String[] args) throws InterruptedException, ExecutionException {
// 创立线程池
ExecutorService es=Executors.newCachedThreadPool();
// 创立 FutureTask 类
FutureTask<Integer> ft=new FutureTask<>(new Task());
// 应用 sumit 办法
es.submit(ft);
// 输入
System.out.println(ft.get());
}
}
class Task implements Callable<Integer>{
@Override
public Integer call() throws Exception {
// TODO Auto-generated method stub
Thread.sleep(1000);
return 3;
}
}
在很多⾼并发的环境下,有可能 Callable 和 FutureTask 会创立屡次。FutureTask 可能在⾼并发环境下确保工作只执⾏⼀次。