在Java中，Runnable、Callable都表示能被线程执行的任务。
Runnable有以下缺陷：
1、没有返回值
2、不能抛出checked exception
Callable接口类似于Runnable，但能返回一个结果，也可以抛出Exception，使用者需要实现call()方法。
/**
* Callable接口源码
*/
@FunctionalInterface
public interface Callable<V> {
/**
* 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;
}Future是一个存储器，存储了Callable的返回结果。
ExecutorService提交任务的部分方法如下
void execute(Runnable command); execute方法只能接收Runnable任务，没有返回值。
<T> Future<T> submit(Callable<T> task); submit方法接收Callable任务，返回结果保存在Future中。
Future<?> submit(Runnable task); submit方法也可接收Runnable任务，返回结果保存在Future中。由于Runnable没有返回值，Future中保存的结果是null。Future的方法
boolean cancel(boolean mayInterruptIfRunning) 尝试取消此任务的执行。
V get() 获取任务结果
V get(long timeout, TimeUnit unit) 限时获取任务结果
boolean isCancelled() 取消任务
boolean isDone() 如果任务完成，返回true。get()方法获取结果有5种情况
1、任务正常完成，get()方法会立刻返回结果。
2、任务尚未完成（任务未开始或进行中），get()将阻塞并直到任务完成。
3、任务执行过程中抛出Exception，get()方法会抛出ExecutionException；不论call()执行时抛出什么异常，最后get()方法抛出的异常类型都是ExecutionException。
4、任务被取消，get方法会抛出CancellationException。
5、任务超时，get方法有一个重载方法，可以传入延迟时间，如果时间到了还没有获得结果，get方法会抛出TimeoutException。
class Future0{
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
// 线程池execute方法执行Runnable任务
executorService.execute(new Task());
// 线程池submit方法执行Runnable任务
Future f = executorService.submit(new Task());
try {
Object data = f.get();
// 使用submit(Runnable task); future.get()返回null
System.out.println("submit(Runnable task)得到的future.get() "+data);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
/**
* 线程池submit方法执行Callable任务
* 执行submit方法时，线程池立刻返回一个空的Future容器，当线程的任务一旦执行完毕，线程池会把结果填入Future中
*/
Future<Integer> future = executorService.submit(new CallableTask());
try {
/**
* 任务正常完成，get()方法会立刻返回结果。
* 任务尚未完成（任务未开始或进行中），get()将阻塞并直到任务完成。
*/
Integer data = future.get();
System.out.println("submit(Callable<T> task)得到的future.get() "+data);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
executorService.shutdown();
}
static class Task implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"run()运行");
}
}
static class CallableTask implements Callable<Integer>{
@Override
public Integer call() throws Exception {
TimeUnit.SECONDS.sleep(2);
return new Random().nextInt(10);
}
}
}/**
* Callable抛出异常时，主线程不会抛异常，直到执行future.get()的时候才会抛异常
* 不论call()执行抛出什么异常，最后get()方法抛出的异常类型都是ExecutionException。
*/
class Future01{
public static void main(String[] args) throws Exception {
ExecutorService executorService = Executors.newFixedThreadPool(10);
Future<Object> future = executorService.submit(() -> {
throw new IllegalArgumentException("在Callable中抛出IllegalArgumentException异常");
});
TimeUnit.SECONDS.sleep(1);
System.out.println("任务是否全部运行完毕。"+future.isDone());
try {
Object o = future.get();
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("抛出InterruptedException");
} catch (ExecutionException e) {
e.printStackTrace();
// System.out.println(e.getCause().getMessage());
System.out.println("抛出ExecutionException");
}
executorService.shutdown();
}
}/**
* 超时与取消任务演示
*
* cancel方法，取消任务
* 1、如果任务还没开始执行，任务会被取消，未来也不会被执行，返回true。
* 2、如果任务已完成或已取消，cancel方法会执行失败，返回false。
* 3、如果任务正在执行，根据cancel(boolean mayInterruptIfRunning)参数取消任务，true取消，false不取消。
* cancel(true)适用于能处理interrupt的任务
* cancel(false)适用于。
* 1、不能处理interrupt的任务，或者调用者不确定任务能否处理interrupt。
* 2、需要等待已经开始的任务执行完成。
*/
class Future02{
private static final ExecutorService exec = Executors.newFixedThreadPool(10);
public static void main(String[] args) {
Future<Ad> future = exec.submit(() -> {
//TimeUnit.MILLISECONDS.sleep(1000);
// 任务超时演示
TimeUnit.MILLISECONDS.sleep(3000);
return new Ad("某程的旅游广告");
});
Ad ad;
try {
ad = future.get(2000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
ad = new Ad("发生中断的默认广告");
} catch (ExecutionException e) {
ad = new Ad("异常时的默认广告");
} catch (TimeoutException e) {
ad = new Ad("超时的默认广告");
System.out.println("超时，执行取消任务");
boolean cancel = future.cancel(true);
System.out.println("cancel的结果："+cancel);
}
System.out.println(ad);
exec.shutdown();
}
static class Ad{
String name;
public Ad(String name) {
this.name = name;
}
@Override
public String toString() {
return "Ad{" +
"name='" + name + '\'' +
'}';
}
}
}还有一个常用的类FutureTask，FutureTask实现了RunnableFuture，RunnableFuture同时继承了Runnable、Future接口，在Java中，接口可以多实现。
FutureTask是一种包装器，其中的一个构造函数是接受Callable类型的参数，既可以作为Callable被线程执行，又可以作为Future得到Callable的返回结果。
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}FutureTask类图如下
class FutureTask1{
static ExecutorService service = Executors.newCachedThreadPool();
public static void main(String[] args) {
// 创建Callable对象
Callable callable = () -> {
System.out.println("子线程正在计算");
TimeUnit.SECONDS.sleep(1);
int sum = 0;
for (int i = 0; i < 100; i++) {
sum += i;
}
return sum;
};
// 使用Callable创建FutureTask
FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
// 线程池提交FutureTask
service.submit(futureTask);
try {
System.out.println("FutureTask运行结果"+futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
service.shutdown();
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
