jdk1.7.0_79
本文实际上是对上文《简单谈谈ThreadPoolExecutor线程池之submit方法》的一个延续或者一个补充。在上文中提到的submit方法里出现了FutureTask，这不得不停止脚步将方向转向Java的Future模式。
Future是并发编程中的一种设计模式，对于多线程来说，线程A需要等待线程B的结果，它没必要一直等待B，可以先拿到一个未来的Future，等B有了结果后再取真实的结果。
|
1
2
3
|
ExecutorService executor = Executors.newSingleThreadExecutor();Future<String> future = executor.submit(callable); //主线程需要callable线程的结果，先拿到一个未来的FutureSystem.out.println(future.get()); //有了结果后再根据get方法取真实的结果,当然如果此时callable线程如果没有执行完get方法会阻塞执行完，如果执行完则直接返回结果或抛出异常 |
也就是说，Future它代表一个异步计算的结果。
上面就代表了Future模式的执行原理，根据网上的例子，我们可以来自己实现一个Future模式。
|
1
2
3
4
5
6
7
8
9
|
package com.future;/** * 数据结果 * Created by yulinfeng on 6/18/17. */public interface Data { String getResult() throws InterruptedException;} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package com.future;/** * 结果的真实计算过程 * Created by yulinfeng on 6/18/17. */public class RealData implements Data { protected String data; public RealData(String data) { try { System.out.println("正在计算结果"); Thread.sleep(3000); //模拟计算 } catch (InterruptedException e) { e.printStackTrace(); } this.data = data + “ world”; } public String getResult() throws InterruptedException { return data; }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package com.future;/** * 真实结果RealData的代理 * Created by yulinfeng on 6/18/17. */public class FutureData implements Data { RealData realData = null; //对RealData的封装，代理了RealData boolean isReady = false; //真实结果是否已经准备好 public synchronized void setResultData(RealData realData) { if (isReady) { return; } this.realData = realData; isReady = true; notifyAll(); //realData已经被注入到了futureData中，通知getResult方法 } public synchronized String getResult() throws InterruptedException { if (!isReady) { wait(); //数据还未计算好，阻塞等待 } return realData.getResult(); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package com.future;/** * Client主要完成的功能包括：1. 返回一个FutureData；2.开启一个线程用于构造RealData * Created by yulinfeng on 6/18/17. */public class Client { public Data request(final String string) { final FutureData futureData = new FutureData(); /*计算过程比较慢，单独放到一个线程中去*/ new Thread(new Runnable() { public void run() { RealData realData = new RealData(string); futureData.setResultData(realData); } }).start(); return futureData; //先返回一个“假”的futureData }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
/** * 负责调用Client发起请求，并使用返回的数据。 * Created by yulinfeng on 6/18/17. */public class Main { public static void main(String[] args) throws InterruptedException { Client client = new Client(); System.out.println("准备计算结果"); Data data = client.request("hello"); //立即返回一个“假”的futureData，可以不用阻塞的等待数据返回，转而执行其它任务 System.out.println("执行其它任务"); Thread.sleep(3000); //模拟执行其它任务 System.out.println("数据的计算结果为：" + data.getResult()); }} |
仔细阅读以上程序对Future模式的实现不难发现，Future模式是异步请求和代理模式的结合。当然在JDK中已经为我们实现好了Future模式。
修改RealData类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package com.future;import java.util.concurrent.Callable;/** * 结果的真实计算过程 * Created by yulinfeng on 6/18/17. */public class RealData2 implements Callable<String> { protected String data; public RealData2(String data) { this.data = data; } public String call() throws Exception { try { System.out.println("正在计算结果"); Thread.sleep(2000); //模拟计算结果 } catch (InterruptedException e) { e.printStackTrace(); } this.data = data + " world"; return data; }} |
修改Main测试类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package com.future;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;/** * 负责调用Executor的submit，并使用返回的数据。 * Created by yulinfeng on 6/18/17. */public class Main2 { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService client = Executors.newSingleThreadExecutor(); //类似Client System.out.println("准备计算结果"); Future<String> data = client.submit(new RealData2("hello")); //类似Client.request System.out.println("执行其它任务"); Thread.sleep(3000); System.out.println("数据的计算结果为：" + data.get()); }} |
现在回到上文还未解决完的AbstractExecutorService#submit方法。
类比上面的Client#request方法，在Client#request中先创建一个FutureData实例，而在AbstractExecutorService#submit中则是创建一个FutureTask实例，接着Client#request新创建一个线程用于异步执行任务，并直接返回FutureData，而在AbstractExecutorService#submit中同样也将任务交给了execute方法，并直接返回FutureTask。当然JDK中Future模式的实现更为复杂。
在《ThreadPoolExecutor线程池原理及其execute方法》中我们讲解了execute方法，在ThreadPoolExecutor$Worker#runWorker方法第1145行中是对task任务的调用：
|
1
2
|
//ThreadPoolExecutor$Worker#runWorkertask.run(); |
submit调用execute以执行run方法，实际执行的是FutureTask中的run方法。在FutureTask#run中，可以看到对任务Callable类型的task异步的执行，以及结果的保存。
以上这篇老生常谈java中的Future模式就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持服务器之家。
