java中的Future模式詳解

下面小編就為大家帶來一篇老生常談java中的Future模式。小編覺得蠻不錯的，現在就分享給大家，也給大家做個參考。一起跟著小編過來看看吧

jdk1.7.0_79

本文其實是對上文《簡單談談ThreadPoolExecutor線程池之submit方法》的一個延續或一個補充。在上文中提到的submit方法裡出現了FutureTask，這不得不停止腳步將方向轉向Java的Future模式。

Future是並發程式設計中的一種設計模式，對於多執行緒來說，執行緒A需要等待執行緒B的結果，它沒必要一直等待B，可以先拿到一個未來的Future，等B有了結果後再取真實的結果。

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

也就是說，Future它代表一個非同步計算的結果。

上面就代表了Future模式的執行原理，根據網路上的例子，我們可以來自己實作一個Future模式。

package com.future;

/**
 * 数据结果
 * Created by yulinfeng on 6/18/17.
 */
public interface Data {
 String getResult() throws InterruptedException;
}

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;
 }
}

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();
 }
}

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
 }
}

/**
 * 负责调用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類別：

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測試類別：

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任務的呼叫：

//ThreadPoolExecutor$Worker#runWorker
task.run();

submit呼叫execute以執行run方法，實際執行的是FutureTask中的run方法。在FutureTask#run中，可以看到對任務Callable類型的task非同步的執行，以及結果的保存。

以上是java中的Future模式詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！