Modèle futur en Java

jdk1.7.0_79

Cet article est en fait une référence à ce qui précède Une continuation ou un supplément de "13.ThreadPoolExecutorThread Pool'ssubmitMéthode". Dans la méthode submit mentionnée ci-dessus, FutureTask est apparue, ce qui m'a obligé à m'arrêter et à changer de direction vers Java Le mode Futur de .

Future est un modèle de conception en programmation simultanée. Pour le multithreading, le thread A doit attendre le thread B, il n'est pas nécessaire d'attendre B Vous pouvez obtenir un avenir Futur<.>, attendez que B ait le résultat et obtenez ensuite le vrai résultat.

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

Autrement dit,

Future

représente le résultat d'un calcul asynchrone.

Ce qui précède représente le principe d'exécution du mode

Futur

Sur la base d'exemples en ligne, nous pouvons en implémenter un nous-mêmes Futur.

1 package com.future;2 3 /**4  * 数据结果5  * Created by yulinfeng on 6/18/17.6  */7 public interface Data {8     String getResult() throws InterruptedException;9 }

 1 package com.future; 2  3 /** 4  * 结果的真实计算过程 5  * Created by yulinfeng on 6/18/17. 6  */ 7 public class RealData implements Data { 8     protected String data; 9 10     public RealData(String data) {11         try {12             System.out.println("正在计算结果");13             Thread.sleep(3000);     //模拟计算14         } catch (InterruptedException e) {15             e.printStackTrace();16         }17         this.data = data + “ world”;18     }19 20     public String getResult() throws InterruptedException {21         return data;22     }23 }

 1 package com.future; 2  3 /** 4  * 真实结果RealData的代理 5  * Created by yulinfeng on 6/18/17. 6  */ 7 public class FutureData implements Data { 8     RealData realData = null;   //对RealData的封装，代理了RealData 9     boolean isReady = false;    //真实结果是否已经准备好10 11     public synchronized void setResultData(RealData realData) {12         if (isReady) {13             return;14         }15         this.realData = realData;16         isReady = true;17         notifyAll();    //realData已经被注入到了futureData中，通知getResult方法18     }19 20     public synchronized String getResult() throws InterruptedException {21         if (!isReady) {22             wait();     //数据还未计算好，阻塞等待23         }24         return realData.getResult();25     }26 }

 1 package com.future; 2  3 /** 4  * Client主要完成的功能包括：1. 返回一个FutureData；2.开启一个线程用于构造RealData 5  * Created by yulinfeng on 6/18/17. 6  */ 7 public class Client { 8  9     public Data request(final String string) {10         final FutureData futureData = new FutureData();11 12         /*计算过程比较慢，单独放到一个线程中去*/13         new Thread(new Runnable() {14 15             public void run() {16                 RealData realData = new RealData(string);17                 futureData.setResultData(realData);18             }19         }).start();20 21         return futureData;  //先返回一个“假”的futureData22     }23 }

Lisez attentivement la mise en œuvre du mode

 1 /** 2  * 负责调用Client发起请求，并使用返回的数据。 3  * Created by yulinfeng on 6/18/17. 4  */ 5 public class Main { 6     public static void main(String[] args) throws InterruptedException { 7         Client client = new Client(); 8         System.out.println("准备计算结果"); 9         Data data = client.request("hello");    //立即返回一个“假”的futureData，可以不用阻塞的等待数据返回，转而执行其它任务10         System.out.println("执行其它任务");11         Thread.sleep(3000);     //模拟执行其它任务12         System.out.println("数据的计算结果为：" + data.getResult());13     }14 }

Future

par le programme ci-dessus. Il n'est pas difficile de constater que le mode Future est le meilleur. requête asynchrone et une combinaison de modèles de proxy . Bien entendu, le mode Future a été implémenté pour nous dans JDK. Modifier RealData

classe :

Modifier

 1 package com.future; 2  3 import java.util.concurrent.Callable; 4  5 /** 6  * 结果的真实计算过程 7  * Created by yulinfeng on 6/18/17. 8  */ 9 public class RealData2 implements Callable<String> {10     protected String data;11 12     public RealData2(String data) {13         this.data = data;14     }15     public String call() throws Exception {16         try {17             System.out.println("正在计算结果");18             Thread.sleep(2000);     //模拟计算结果19         } catch (InterruptedException e) {20             e.printStackTrace();21         }22         this.data = data + " world";23         return data;24     }25 }

Main

Catégorie Test :

　　现在回到上文还未解决完的AbstractExecutorService#submit方法。

　　类比上面的Client#request方法，在Client#request中先创建一个FutureData实例，而在AbstractExecutorService#submit中则是创建一个FutureTask实例，接着Client#request新创建一个线程用于异步执行任务，并直接返回FutureData，而在AbstractExecutorService#submit中同样也将任务交给了execute方法，并直接返回FutureTask。当然JDK中Future模式的实现更为复杂。

　　在《12.ThreadPoolExecutor线程池原理及其execute方法》中我们讲解了execute方法，在ThreadPoolExecutor$Worker#runWorker方法第1145行中是对task任务的调用：

//ThreadPoolExecutor$Worker#runWorkertask.run();

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

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!