深入浅出Future Pattern
深入浅出Future Pattern
散关清渭 发表于3年前
深入浅出Future Pattern
  • 发表于 3年前
  • 阅读 27
  • 收藏 0
  • 点赞 0
  • 评论 0
摘要: Future是这样一种Pattern: 它本身表示‘将来(future)’,你提交一个异步的任务,比如提交到一个threadpool,与此同时拿到一个Future对象,任务的执行是异步的,这时候你可以去做其它的事情,等到异步任务结束的时候,你可通过前面的Future对象拿到异步执行的任务的结果。

Future是这样一种Pattern: 它本身表示‘将来(future)’

你提交一个异步的任务  比如提交到一个threadpool

与此同时拿到一个Future对象  任务的执行是异步的

这时候你可以去做其它的事情  等到异步任务结束的时候  你可通过前面的Future对象拿到异步执行的任务的结果


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask; 

public class FutureTest {   
  public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(1); 
    Future< String> future = executor.submit(new Callable< String>() {
      public String call() {
        return "Hello futue!";
      }
    });     
    
    try {
      Thread.sleep(1000);
      System.out.println(future.get());
    } catch (InterruptedException e) {
      future.cancel(true);
    } catch (ExecutionException e) {
      future.cancel(true);
    } finally {
      executor.shutdown();
    }
  }}



异步执行结束后,自动通知用户异步任务结束了,你可以通过Future来获取执行结果了。

这就诞生了google的ListenableFuture,用户可以向它注册一个回调函数和提供一个线程池(可选),

当异步任务执行结束后,它会自动在用户提供的线程池里调用用户注册的回调函数,通知用户异步任务执行结束了。

当然,如果用户不提供线程池,它会在运行异步任务的工作线程里运行回调函数,

这种情况适用于工作线程本身的任务比较轻量级的情景。


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors; 
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors; 

public class ListenableFutureTest {   
  public static void main(String[] args) {
    ListeningExecutorService executor = MoreExecutors.listeningDecorator(
        Executors.newFixedThreadPool(1));     
        final ListenableFuture< String> future = executor.submit(
          new Callable< String>() {
            public String call() throws Exception {
              return "Hello listenable future";
            }
      }); 
      
    future.addListener(new Runnable() {
      public void run() {
        try {
          System.out.println(future.get());
        } catch (InterruptedException e) {
          future.cancel(true);
        } catch (ExecutionException e) {
          future.cancel(true);
        }
      }
    }, Executors.newFixedThreadPool(1));     System.out.println("exit..");
  }}


import java.util.concurrent.Callable;
import java.util.concurrent.Executors; 
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors; 

public class ListenableFutureTest2 {   
  public static void main(String[] args) {
    ListeningExecutorService executor = MoreExecutors.listeningDecorator(
        Executors.newFixedThreadPool(1));     
        final ListenableFuture< String> future = executor.submit(
          new Callable< String>() {
          public String call() throws Exception {
            return "Hello listenable future";
      }
    });
     
    Futures.addCallback(future, new FutureCallback< String>() {
      public void onSuccess(String result) {
        System.out.println(result);
      }
      
       public void onFailure(Throwable t) {
        System.out.println("error: " + t);
       }     
       }, Executors.newFixedThreadPool(1));     
       
       System.out.println("exit..");
  }}










共有 人打赏支持
粉丝 23
博文 159
码字总数 166498
×
散关清渭
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: