Java源码之Future

 

 

转载请注明出处：http://blog.csdn.net/itismelzp/article/details/77761112

 

一、Future概述

 

Future用于表示异步计算模型的结果。它的方法包括：检测是否计算完成、等待计算完成、返回计算结果。

如果计算结束，使用get()函数可以返回结果，如果计算正在进行，get()函数将阻塞以等待计算结果。

cancel()方法用于取消计算，并返回是否取消成功。isCanceled()返回是否取消成功，一但计算已结束，将无法再取消。

如果想使用一种可取消的计算，并且不提供一个可用的结果。可用声明Future<?>，并返回null。

 

下面是Future的源码：

package java.util.concurrent; /** * @see FutureTask * @see Executor * @since 1.5 * @author Doug Lea * @param <V> The result type returned by this Future's {@code get} method */ public interface Future<V> { /** * 尝试取消任务 * * mayInterruptIfRunning为true时尝试取消当前任务parameter determines * 并返回是否取消成功结果 */ boolean cancel(boolean mayInterruptIfRunning); /** * 返回任务是否在完成前被取消. */ boolean isCancelled(); /** * 返回任务是否完成. * * 任务被中断/取消/正常完成/异常都会返回true. * */ boolean isDone(); /** * 等待并返回计算结果 * * 如果结果被取消抛CancellationException异常 * 如果等待被中断抛InterruptedException异常 * 如果当前线程被中断抛ExecutionException异常 * */ V get() throws InterruptedException, ExecutionException; /** * 设置等待时间，等待并返回计算结果 * * 如果结果被取消抛CancellationException异常 * 如果等待被中断抛InterruptedException异常 * 如果当前线程被中断抛ExecutionException异常 * */ V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }

 

 

 

 

 

二、Future初探

 

在并发编程时，一般使用runnable，然后扔给线程池完事，这种情况下不需要线程的结果，所以run的返回值是void类型。  如果是一个多线程协作程序，比如线程A需要线程B的结果，就需要用callable接口了。 callable用法和runnable一样，只不过调用的是call方法，该方法有一个泛型返回值类型，你可以任意指定。  线程是属于异步计算模型，所以你不可能直接从别的线程中得到函数返回值。 这时候，Future就出场了。Futrue可以监视目标线程调用call的情况，当你调用Future的get()方法以获得结果时，当前线程就开始阻塞，直接call方法结束返回结果。  下面三段简单的代码可以很简明的揭示这个意思：

 

public class RunnableTest { public static class Task implements Runnable { @Override public void run() { System.out.println("thread runing..."); } } public static void main(String[] args) { ExecutorService es = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { es.submit(new Task()); } } }

runnable接口实现的没有返回值的并发编程。

 

public class FutureTest { public static class Task implements Callable<String> { @Override public String call() throws Exception { System.out.println("do something ..."); return "result"; } } public static void main(String[] args) throws Exception { ExecutorService es = Executors.newCachedThreadPool(); List<Future<String>> results = new ArrayList<>(); for (int i = 0; i < 10; i++) { results.add(es.submit(new Task())); } } }

callable实现的存在返回值的并发编程。（call的返回值String受泛型的影响）

 

 

public class FutureTest { public static class Task implements Callable<String> { @Override public String call() throws Exception { System.out.println("do something ..."); return "result"; } } public static void main(String[] args) throws Exception { ExecutorService es = Executors.newCachedThreadPool(); List<Future<String>> results = new ArrayList<>(); for(int i = 0; i < 10; i++) { results.add(es.submit(new Task())); } // 获取执行结果 for(Future<String> f : results) { System.out.println(f.get()); } } }

运行结果：

 

 

 

三、Future实现

 

3.1 Future模式核心思想

Future模式的核心在于：去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑（根据《Java程序性能优化》）。 Future模式有点类似于商品订单。在网上购物时，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的时一直等待到这个答复收到时再去做别的事情，但如果利用Future设计模式就无需等待答复的到来，在等待答复的过程中可以干其他事情。 例如如下的请求调用过程时序图。当call请求发出时，需要很长的时间才能返回。左边的图需要一直等待，等返回数据后才能继续其他操作；而右边的Future模式的图中客户端则无需等到可以做其他的事情。服务器段接收到请求后立即返回结果给客户端，这个结果并不是真实的结果（是虚拟的结果），也就是先获得一个假数据，然后执行其他操作。

 

 

 

 

 

3.2  Future模式Java实现

 

Client的实现，Client主要完成两个功能：

 

1）返回一个FutureData；

2）开启一个线程用于构造RealData。

 

public class Client { public Data request(final String string) { final FutureData futureData = new FutureData(); new Thread(new Runnable() { @Override public void run() { //RealData的构建很慢，所以放在单独的线程中运行 RealData realData = new RealData(string); futureData.setRealData(realData); } }).start(); return futureData; //先直接返回FutureData } }

 

Data的实现 无论是FutureData还是RealData都实现该接口。

public interface Data { String getResult() throws InterruptedException; }

 

FutureData的实现 FutureData是Future模式的关键，它实际上是真实数据RealData的代理，封装了获取RealData的等待过程。

//FutureData是Future模式的关键，它实际上是真实数据RealData的代理，封装了获取RealData的等待过程 public class FutureData implements Data { RealData realData = null; //FutureData是RealData的封装 boolean isReady = false; //是否已经准备好 public synchronized void setRealData(RealData realData) { if(isReady) return; this.realData = realData; isReady = true; notifyAll(); //RealData已经被注入到FutureData中了，通知getResult()方法 } @Override public synchronized String getResult() throws InterruptedException { if(!isReady) { wait(); //一直等到RealData注入到FutureData中 } return realData.getResult(); } }

RealData的实现 RealData是最终需要使用的数据，它的构造函数很慢。

public class RealData implements Data { protected String data; public RealData(String data) { //利用sleep方法来表示RealData构造过程是非常缓慢的 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } this.data = data; } @Override public String getResult() { return data; } }

 

 

 

测试运行 主函数主要负责调用Client发起请求，并使用返回的数据。

 

public class Application { public static void main(String[] args) throws InterruptedException { Client client = new Client(); //这里会立即返回，因为获取的是FutureData，而非RealData Data data = client.request("name"); //这里可以用一个sleep代替对其他业务逻辑的处理 //在处理这些业务逻辑过程中，RealData也正在创建，从而充分了利用等待时间 Thread.sleep(2000); //使用真实数据 System.out.println("数据="+data.getResult()); } }

 

 

 

 

3.3 Future模式的JDK内置实现

由于Future是非常常用的多线程设计模式，因此在JDK中内置了Future模式的实现。这些类在java.util.concurrent包里面。其中最为重要的是FutureTask类，它实现了Runnable接口，作为单独的线程运行。在其run()方法中，通过Sync内部类调用Callable接口，并维护Callable接口的返回对象。当使用FutureTask.get()方法时，将返回Callable接口的返回对象。同样，针对上述的实例，如果使用JDK自带的实现，则需要作如下调整。 首先，Data接口和FutureData就不需要了，JDK帮我们实现了。 其次，RealData改为这样：

 

import java.util.concurrent.Callable; public class RealData implements Callable { protected String data; public RealData(String data) { this.data = data; } @Override public String call() throws Exception { //利用sleep方法来表示真是业务是非常缓慢的 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } return data; } }

最后，在测试运行时，这样调用：

 

 

 

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.FutureTask; public class Application { public static void main(String[] args) throws Exception { FutureTask futureTask = new FutureTask(new RealData("name")); ExecutorService executor = Executors.newFixedThreadPool(1); //使用线程池 //执行FutureTask，相当于上例中的client.request("name")发送请求 executor.submit(futureTask); //这里可以用一个sleep代替对其他业务逻辑的处理 //在处理这些业务逻辑过程中，RealData也正在创建，从而充分了利用等待时间 Thread.sleep(2000); //使用真实数据 //如果call()没有执行完成依然会等待 System.out.println("数据=" + futureTask.get()); } }

 

 

 

 

 

 

参考：

[1] http://www.oschina.net/question/54100_83333

[2] http://blog.csdn.net/ghsau/article/details/7451464

[3] https://www.2cto.com/kf/201411/351903.html