老生常谈java中的Future模式

时间:2021-09-10 17:03:31

jdk1.7.0_79

本文实际上是对上文《简单谈谈ThreadPoolExecutor线程池之submit方法》的一个延续或者一个补充。在上文中提到的submit方法里出现了FutureTask,这不得不停止脚步将方向转向JavaFuture模式

Future是并发编程中的一种设计模式,对于多线程来说,线程A需要等待线程B的结果,它没必要一直等待B,可以先拿到一个未来的Future,等B有了结果后再取真实的结果。

java" id="highlighter_235684">
?
1
2
3
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(callable); //主线程需要callable线程的结果,先拿到一个未来的Future
System.out.println(future.get()); //有了结果后再根据get方法取真实的结果,当然如果此时callable线程如果没有执行完get方法会阻塞执行完,如果执行完则直接返回结果或抛出异常

也就是说,Future它代表一个异步计算的结果。

老生常谈java中的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#runWorker
task.run();

submit调用execute以执行run方法,实际执行的是FutureTask中的run方法。在FutureTask#run中,可以看到对任务Callable类型的task异步的执行,以及结果的保存。

以上这篇老生常谈java中的Future模式就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持服务器之家。