1.1 综述

创建线程有两种方式：extends Thread || inplements Runable，但是这两种方式都有一个缺陷，就是执行完任务后不能获取执行结果。

如果非要获取到执行结果的话，就必须通过共享变量或者是线程通信的方法来达到效果，使用较为麻烦，为了解决这种问题，java提供了Callable Future ，通过他们可以再任务执行完毕后得到任务执行结果。

1.2 Runable Callable 对比

java.lang.Runable是一个接口，声明了run()方法：

public interface Runable {public abstract void run();
}

因为run()方法返回值void，所以执行完任务后不能返回结果。
java.util,concurrent.Callable 也是一个接口，里面声明了一个方法call();

public interface Callable<V> {V call() throws Exception;
}

call{}函数返回的类型就是这个传递进来的V类型，使用Callable 就需要配合ExecutorService配合使用：

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

1.3 Future 接口 方法含义

Future类位于java.util.concurrent包下，它是一个接口

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方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
          isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
           isDone方法表示任务是否已经完成，若任务完成，则返回true；
          get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
          get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

1.4 Future FutureTask 相关

因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。
FutureTask是Future接口的一个唯一实现类。

public class FutureTask<V> implements RunnableFuture<V>public interface RunnableFuture<V> extends Runnable, Future<V> {void run();
}

FutureTask提供了2个构造器：

public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}

1.5 代码示例

示例

package com.test.java.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.Future;public class Test {public static void main(String[] args) {ExecutorService executor = Executors. newCachedThreadPool();Task task = new Task();Future<Integer> result = executor.submit(task);executor.shutdown();try {Thread. sleep(1000);} catch (InterruptedException e1) {e1.printStackTrace();}System. out.println("主线程在执行任务" );try {System. out.println("task运行结果" + result.get());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}System. out.println("所有任务执行完毕" );}
}class Task implements Callable<Integer> {@Overridepublic Integer call() throws Exception {System. out.println("子线程在进行计算" );Thread. sleep(3000);int sum = 0;for (int i = 0; i < 100; i++)sum += i;return sum;}
}package com.test.java.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 Test1 {public static void main(String[] args) {// 第一种方式ExecutorService executor = Executors. newCachedThreadPool();Task1 task = new Task1();FutureTask<Integer> futureTask = new FutureTask<Integer>(task);executor.submit(futureTask);executor.shutdown();// 第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread/** Task task = new Task(); FutureTask<Integer> futureTask = new* FutureTask<Integer>(task); Thread thread = new Thread(futureTask);* thread.start();*/try {Thread. sleep(1000);} catch (InterruptedException e1) {e1.printStackTrace();}System. out.println("主线程在执行任务" );try {System. out.println("task运行结果" + futureTask.get());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}System. out.println("所有任务执行完毕" );}
}class Task1 implements Callable<Integer> {@Overridepublic Integer call() throws Exception {System. out.println("子线程在进行计算" );Thread. sleep(3000);int sum = 0;for (int i = 0; i < 100; i++)sum += i;return sum;}
}

1.6 另外一个恰当的示例说明

举个简单的例子：当你在网上购物时，如果付款成功了，你是否立即拿到了你买到的商品？当然不是，当你付款成功时，你得到的仅仅是一个，订单提交成功的提示而已，其它的什么都没了，从这一刻开始，你是否会一直呆在家里，什么都不做，直到你的商品送到你手中呢？当然也不是，当你订单提交成功后，你会去做你该做的，当你的商品送到时，你只需签收一下即可，从订单提交到商品送到之间，你不会因为等待商品送到而耽误你的时间，你可以自由支配你的时间，好像什么都没有发生一样。
是的，Future模式就是这个意思
当客户提交一个请求时，这个请求有可能会花很长一段时间去处理后台数据，之后，再返回给客户一个处理过的数据，那这段时间，客户一直在等待服务端的响应，是不是会让客户觉得很厌烦呢？当然会了，所以Future模式就是为了提高响应时间而诞生的，当然这个提高其实是一个假象。当客户提交一个请求时，我们让客户立即返回一个虚拟的数据响应，之后，客户端就不用为了等待响应而无事可做了，此后，客户端可以进行别的任何操作，当真正的数据处理完返回给客户了，客户再去进行相应的处理，这样就会让客户没有无谓的等待了.

package com.test.java.future;import java.util.concurrent.Callable;public class MyData implements Callable<String> {private String myStr ;public MyData(String myStr) {this .myStr = myStr;}@Overridepublic String call() throws Exception {StringBuffer sb = new StringBuffer();for (int i=0;i<10;i++) {sb.append( myStr);try {Thread. sleep(1000);} catch (Exception e) {e.printStackTrace();}}return sb.toString();}}

package com.test.java.future;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;public class MyDataTest {public static void main(String[] args) {FutureTask<String> future = new FutureTask<String>( newMyData("alexgaoyh" ));ExecutorService exe = Executors. newFixedThreadPool(1);exe.submit(future);exe.shutdown();System. out .println("客户端请求结束了" );System. out .println("任务是否已经完成：" +future.isDone());try {/** 这段时间，就是后台在获取真正数据的时间*/System. out .println("在这段时间，我可以做我自己的事情" );System. out .println("真正的数据:" +future.get());System. out .println("任务是否已经完成：" +future.isDone());} catch (Exception e) {e.printStackTrace();}}}