03.ListenableFuture和Futures

一、作用

jdk1.8之前的Future模式一个最大的问题是：向线程池提交任务异步执行并获取的Future对象后，需要获取结果做后续处理操作的时候，还是需要阻塞某线程进行等待。这样的话，和同步调用方式就没有多大区别了。而ListenableFuture和CompletableFuture对于这种情况则是提供了很多易用的API。

如果说按照先后顺序来讲的话，首先是ListenableFuture，这是由Google Guava工具包提供的Future扩展类，随后，JDK在1.8版本中马上也提供了类似这样的类，就是CompletableFuture。

如果项目使用的jdk版本是1.8及以上，则直接使用CompletableFuture就可以了，下面分别介绍这两种工具的使用：

二、Google的ListenableFuture

先来聊聊ListenableFuture，一句话概括ListenableFuture和JDK原生Future最大的区别是前者做到了一个可以监听结果的Future。换个更通俗的讲法，就是它可以监听异步执行的过程，执行完了，自动触发什么操作。除此之外，可以分别针对成功的情况，或者失败的情况做各种后续处理

package com.mzj.guava.concurrent.future;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;

import org.junit.Test;

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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ListenableFutureExample {

    /**
     * The unit test for ListenableFuture/CompletableFuture. * Created by yiqun01.lin * on 2018/5/3.
     */
    //线程池中线程个数
    private static final int POOL_SIZE = 50;
    //带有回调机制的线程池
    private static final ListeningExecutorService service = MoreExecutors
            .listeningDecorator(Executors.newFixedThreadPool(POOL_SIZE));

    private static Logger LOG = LoggerFactory.getLogger(ListenableFutureExample.class);

    @Test
    public void testListenableFuture() {
        final List<String> value = Collections
                .synchronizedList(new ArrayList<String>());
        try {
            List<ListenableFuture<String>> futures = new ArrayList<ListenableFuture<String>>();
            // 将实现了callable的任务放入到线程池中，得到一个带有回调机制的ListenableFuture实例，
            // 通过Futures.addCallback方法对得到的ListenableFuture实例进行监听，一旦得到结果就进入到onSuccess方法中，
            // 在onSuccess方法中将查询的结果存入到集合中
            for (int i = 0; i < 1; i++) {
                final int index = i;
                if (i == 9) {
                    Thread.sleep(500 * i);
                }
                ListenableFuture<String> sfuture = service
                        .submit(new Callable<String>() {
                            @Override
                            public String call() throws Exception {
                                long time = System.currentTimeMillis();
                                LOG.info("Finishing sleeping task{}: {}", index, time);
                                return String.valueOf(time);
                            }
                        });
                sfuture.addListener(new Runnable() {
                    @Override
                    public void run() {
                        LOG.info("Listener be triggered for task{}.", index);
                    }
                }, service);

                Futures.addCallback(sfuture, new FutureCallback<String>() {
                    public void onSuccess(String result) {
                        LOG.info("Add result value into value list {}.", result);
                        value.add(result);
                    }

                    public void onFailure(Throwable t) {
                        LOG.info("Add result value into value list error.", t);
                        throw new RuntimeException(t);
                    }
                });
                // 将每一次查询得到的ListenableFuture放入到集合中
                futures.add(sfuture);
            }

            // 这里将集合中的若干ListenableFuture形成一个新的ListenableFuture
            // 目的是为了异步阻塞，直到所有的ListenableFuture都得到结果才继续当前线程
            // 这里的时间取的是所有任务中用时最长的一个
            ListenableFuture<List<String>> allAsList = Futures.allAsList(futures);
            allAsList.get();
            LOG.info("All sub-task are finished.");
        } catch (Exception ignored) {
        }
    }


}

三、JDK1.8的CompletableFuture

我们再来看看CompletableFuture的使用，这个是在JDK8中开始引入的，这个在一定程度上与ListenableFuture非常类似。比如说ListenableFuture的listener监听回调，在这个类中，相当于thenRun或者whneComplete操作原语。CompletableFuture提供的API其实有很多，从大的方向上来划分的话，有下面几类：

public static CompletableFuture<Void>     runAsync(Runnable runnable)  
public static CompletableFuture<Void>     runAsync(Runnable runnable, Executor executor)  
public static <U> CompletableFuture<U>  supplyAsync(Supplier<U> supplier)  
public static <U> CompletableFuture<U>  supplyAsync(Supplier<U> supplier, Executor executor)

注意到这里，runAsync是不带类型返回的，Void，而supplyAsync API需要传入类型的，整型，字符串或者其它，然后是否需要在额外的线程池里执行这些Async操作，如果没有指定，会默认在ForkJoinPool提供的common pool里跑

CompletableFuture在设计上采用JDK1.8原生的函数式编程风格。

package com.mzj.guava.concurrent.future;

import java.util.concurrent.CompletableFuture;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CompletableFutureExample {

        private static Logger LOG = LoggerFactory.getLogger(CompletableFutureExample.class);

        @Test
        public void testCompletableFuture() throws Exception {
            // case1: supplyAsync
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
                LOG.info("Run supplyAsync.");
                return "Return result of Supply Async";
            });

            // case2: thenRun，与supplyAsync同线程
            future.thenRun(new Runnable() {

                @Override
                public void run() {
                    LOG.info("Run action.");
                }
            });

            // case2: thenRunAsync，另启动线程执行
            future.thenRunAsync(new Runnable() {

                @Override
                public void run() {
                    LOG.info("Run async action.");
                }
            });

            // 主动触发Complete结束方法
            // future.complete("Manual complete value.");
            future.whenComplete((v, e) -> {
                LOG.info("WhenComplete value: " + v);
                LOG.info("WhenComplete exception: " + e);
            });
            CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
                LOG.info("Return result of Run Async.");
            });

            CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
                return "hello";
            });
            CompletableFuture<String> future4 = CompletableFuture.supplyAsync(() -> {
                return "world";
            });
            CompletableFuture<String> f = future3.thenCombine(future4,
                    (x, y) -> x + "-" + y);
            LOG.info(f.get());
        }
}

四、完整工程示例

https://github.com/mazhongjia/googleguava/tree/master/src/main/java/com/mzj/guava/concurrent/future

五、扩展阅读

jdk的CompletableFuture接口较多，可以阅读如下文章加强理解

https://www.jianshu.com/p/6bac52527ca4

https://www.jianshu.com/p/b3c4dd85901e

——E:\01.study\10.java基础\java8\01.CompletableFuture

来源：CSDN

作者：mazhongjia

链接：https://blog.csdn.net/mazhongjia/article/details/104180678

标签

string

completablefuture