Zukünftiges Muster in Java

jdk1.7.0_79

Dieser Artikel ist eigentlich eine Referenz auf das Obige Eine Fortsetzung oder Ergänzung von „13.ThreadPoolExecutorThread Pool'ssubmitMethod“. In der oben erwähnten submit-Methode erschien FutureTask, was mich zwang, anzuhalten und die Richtung zu Java zu ändern s Zukunftsmodus.

Zukunft ist ein Entwurfsmuster in der gleichzeitigen Programmierung, Thread A muss auf Thread B, es besteht keine Notwendigkeit, auf B zu warten. Sie können zuerst eine Zukunft Zukunft erhalten , warten Sie, bis B das Ergebnis hat, und erhalten Sie dann das tatsächliche Ergebnis.

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

Mit anderen Worten:

Future stellt das Ergebnis einer asynchronen Berechnung dar.

Das Obige stellt das Ausführungsprinzip des

Zukunftsmusters dar. Basierend auf Online-Beispielen können wir eines selbst implementieren ZukunftModus.

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 }

 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 }

Lesen Sie sorgfältig die Implementierung des

Future-Musters im obigen Programm. Es ist nicht schwer herauszufinden, dass das Future-Muster das ist asynchrone Anfrage und eine Kombination von Proxy-Mustern . Natürlich wurde der Future-Modus für uns im JDK implementiert.

Ändern

RealData Klasse:

 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 }

Ändern

MainTestkategorie:

 1 package com.future; 2  3 import java.util.concurrent.ExecutionException; 4 import java.util.concurrent.ExecutorService; 5 import java.util.concurrent.Executors; 6 import java.util.concurrent.Future; 7  8 /** 9  * 负责调用Executor的submit，并使用返回的数据。10  * Created by yulinfeng on 6/18/17.11  */12 public class Main2 {13 14     public static void main(String[] args) throws InterruptedException, ExecutionException {15         ExecutorService client = Executors.newSingleThreadExecutor();   //类似Client16         System.out.println("准备计算结果");17         Future<String> data = client.submit(new RealData2("hello"));    //类似Client.request18         System.out.println("执行其它任务");19         Thread.sleep(3000);20         System.out.println("数据的计算结果为：" + data.get());21     }22 }

　　现在回到上文还未解决完的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异步的执行，以及结果的保存。

Das obige ist der detaillierte Inhalt vonZukünftiges Muster in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!