Explication détaillée du modèle Future en Java

L'éditeur ci-dessous vous présentera un cliché sur le mode Future en Java. L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Venez jeter un oeil avec l'éditeur

jdk1.7.0_79

Cet article est en fait une continuation ou un supplément à celui ci-dessus "Parlez brièvement de la méthode de soumission du pool de threads ThreadPoolExecutor". FutureTask est apparu dans la méthode de soumission mentionnée ci-dessus, ce qui m'a obligé à m'arrêter et à passer au mode Future de Java.

Future est un modèle de conception en programmation simultanée. Pour le multi-threading, le thread A doit attendre le résultat du thread B. Il n'a pas besoin d'attendre B tout le temps. Il peut obtenir un premier futur. Le futur obtiendra le résultat réel une fois que B aura obtenu le résultat.

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

En d'autres termes, Future représente le résultat d'un calcul asynchrone.

Ce qui précède représente le principe d'exécution du mode Future. D'après des exemples en ligne, nous pouvons implémenter nous-mêmes un mode 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());
 }
}

Lisez attentivement l'implémentation du mode Future dans le programme ci-dessus. Il n'est pas difficile de constater que le mode Future est une combinaison de requêtes asynchrones et <.>Mode proxy . Bien entendu, le mode Future a été implémenté pour nous dans le JDK.

Modifiez la classe 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;
 }
}

Modifiez la classe de test 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());
 }
}

Retournez maintenant au AbstractExecutorService qui n'a pas été résolu encore.

Analogue à la méthode Client#request ci-dessus, une instance FutureData est d'abord créée dans Client#request, et une instance FutureTask est créée dans AbstractExecutorService#submit, puis Client#request crée un nouveau thread pour une exécution asynchrone. tâche et renvoie directement FutureData. Dans AbstractExecutorService#submit, la tâche est également transmise à la méthode d'exécution et renvoie directement FutureTask. Bien entendu, l'implémentation du mode Future dans le JDK est plus compliquée.

Dans "

Principe du pool de threads ThreadPoolExecutor et sa méthode d'exécution " nous avons expliqué la méthode d'exécution. La ligne 1145 de la méthode ThreadPoolExecutor$Worker#runWorker est l'appel à la tâche :

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

submit appelle exécuter pour exécuter la méthode run Ce qui est réellement exécuté est la méthode run dans FutureTask. Dans FutureTask#run, vous pouvez voir l'exécution asynchrone des tâches de type Callable et la sauvegarde des résultats.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!