Guava库学习：学习Concurrency（八）Futures

最新推荐文章于 2022-11-18 23:51:49 发布

weixin_33709590

最新推荐文章于 2022-11-18 23:51:49 发布

阅读量324

点赞数

文章标签： python java git

原文链接：https://my.oschina.net/realfighter/blog/350019

版权

2019独角兽企业重金招聘Python工程师标准>>>

链接地址：http://www.xx566.com/detail/163.html

Futures是Guava Concurrency提供的用于处理Future实例的工具类，其中提供了需要有用方便的方法，一些方法的使用也有特定的场景，之前的学习中，我们提到了AsyncFution和FutureFallback，本篇我们重点来学习一些与之相关的方法：AsyncFunctions 以及FutureFallbacks。

之前的学习中，我们已经学习到了Futures的一些方法，如：Futures.addFallback，用于注册一个FutureCallback实例，在ListenableFuture实例完成其任务后执行。

异步转换

Guava库学习：学习Concurrency（六）AsyncFunction中，我们学习了AsyncFunction接口，以及如何接收Fuction进行异步的转换，Futures提供了transform方法，使我们能够简便的使用AsyncFunction接口：

@Test
public void testFuturesTransform() throws ExecutionException, InterruptedException {
    listenableFuture = executorService.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "张三";
        }
    });
    AsyncFunction<String, Person> asyncFunction = new AsyncFunction<String, Person>() {
        @Override
        public ListenableFuture<Person> apply(String input) throws Exception {
            person.setName(input);
            return executorService.submit(new Callable<Person>() {
                @Override
                public Person call() throws Exception {
                    return person;
                }
            });
        }
    };
    ListenableFuture<Person> lf =
            Futures.transform(listenableFuture, asyncFunction);
    assertThat(lf.get().getName(), is("张三"));
}

Futures.transform方法返回了一个ListenableFuture实例，其结果是通过对从传递到方法中的ListenableFuture的执行结果进行一个异步的转换。

FutureFallbacks的应用

Guava库学习：学习Concurrency（七）FutureFallback中，我们同样学习了FutureFallback接口，能够帮助我们处理ListenableFuture执行出现的错误信息，Futures.withFallback方法使用类似的方法注册FutureFallback，我们可以像下面这样使用：

@Test
public void testFuturesFallback() throws ExecutionException, InterruptedException {
    listenableFuture = executorService.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            throw new RuntimeException();
        }
    });
    FutureFallback<String> futureFallback = new FutureFallback<String>() {
        @Override
        public ListenableFuture create(Throwable t) throws Exception {
            if (t instanceof RuntimeException) {
                SettableFuture<String> settableFuture =
                        SettableFuture.create();
                settableFuture.set("Not Found");
                return settableFuture;
            }
            throw new Exception(t);
        }
    };
    ListenableFuture<String> lf =
            Futures.withFallback(listenableFuture,futureFallback);
    assertThat(lf.get(), is("Not Found"));
}

Futures.withFallback方法返回了一个ListenableFuture实例，其接收一个listenableFuture参数和 futureFallback参数，如果给定的listenableFuture执行成功，则返回成功的结果，如果失败，则返回 FutureFallback中设置的错误信息。

接下来，我们翻开Futures的源码，简单的整理一下其中的公共方法，如下：

makeChecked( ListenableFuture<V> future, Function<Exception, X> mapper)：根据传入ListenableFuture和Function构建一个CheckFuture，映射异常的实例到相应的检查类型。

immediateFuture(@Nullable V value)：创建一个设置value值的ListenableFuture，其value值立即会被设置，getter方法只是返回值。这个 Future不能取消或超时，Future的isDone()方法总是返回true。

immediateFailedFuture( Throwable throwable)：返回一个构造时设置传入异常的ListenableFuture，返回的Future不能被取消，isDone()方法总是返回 true，调用get()方法会抛出被ExecutionException包装的Throwable。

immediateCancelledFuture()：创建一个会被立即取消的ListenableFuture，所以isCancelled()方法总是返回true。

immediateCheckedFuture(@Nullable V value)：返回一个CheckedFuture，构造时其value值立即会被设置，返回的Future不能被取消，isDone()方法总是返回 true，调用get()或者checkGet()方法会立即返回设置的value值。

immediateFailedCheckedFuture(X exception)：返回一个构造时设置传入异常的CheckedFuture，返回的Future不能被取消，isDone()方法总是返回 true，调用get()方法会抛出被ExecutionException包装的Exception，调用checkGet()方法会抛出给定的 exception异常。

withFallback( ListenableFuture<? extends V> input, FutureFallback<? extends V> fallback)：返回一个Future，其结果来自于ListenableFuture，如果ListenableFuture出现失败，则结果由给定的FutureFallback产生。

withFallback( ListenableFuture<? extends V> input, FutureFallback<? extends V> fallback, Executor executor)：返回一个Future，其结果来自于ListenableFuture，如果ListenableFuture出现失败，则结果由给定的FutureFallback产生，并由给定的executor提供线程单独运行FutureFallback。

transform(ListenableFuture input, AsyncFunction<? super I, ? extends O> function)：创建一个新的ListenableFuture，它的结果异步来自于给定ListenableFuture的结果，更准确的说，返回的结果是由原始的结果应用给定的function后的结果。

transform(ListenableFuture input, AsyncFunction<? super I, ? extends O> function, Executor executor)：创建一个新的ListenableFuture，它的结果异步来自于给定ListenableFuture的结果，更准确的说，返回的结果是由原始的结果应用给定的function后的结果，给定的function操作由executor执行。

transform(ListenableFuture input, final Function<? super I, ? extends O> function)：创建一个新的ListenableFuture，它的结果是给定input ListenableFuture的结果应用给定的function后的结果。

transform(ListenableFuture input, final Function<? super I, ? extends O> function, Executor executor)：创建一个新的ListenableFuture，它的结果是给定input ListenableFuture的结果应用给定的function后的结果，给定的function操作由executor执行。

lazyTransform(final Future input, final Function<? super I, ? extends O> function)：与transform方法类似，不过function的转换过程会每次调用返回的Future的get()方法。

dereference( ListenableFuture<? extends ListenableFuture<? extends V>> nested)：返回一个新的ListenableFuture，它的结果是给定nested ListenableFuture调用get()的结果，此方法能够有效的将一个ListenableFuture链接到另一个ListenableFuture。

allAsList( ListenableFuture<? extends V>... futures)：创建一个新的ListenableFuture，当给定的futures集合中future都完成时返回结果的list，如果任一 future失败，则创建的ListenableFuture会失败。

allAsList( Iterable<? extends ListenableFuture<? extends V>> futures)：创建一个新的ListenableFuture，当给定的futures集合中future都完成时返回结果的list，如果任一 future失败，则创建的ListenableFuture会失败。

nonCancellationPropagating( ListenableFuture<V> future)：创建一个新的ListenableFuture，当给定的future完成时，它的结果才会被设置。取消给定的future也会取消返回的ListenableFuture，但是取消返回的ListenableFuture对给定的future没有影响。

successfulAsList( ListenableFuture<? extends V>... futures)：创建一个新的ListenableFuture，它的值是一个列表包含所有传入Future集合中Future执行成功后返回的值，结果的顺序与传入集合的顺序一致，如果任何一个传入集合中的Future失败或被取消，其对应的位置的值将会被设置为null，（这导致了将无法区别执行成功后返回值为null的任务）。

successfulAsList( Iterable<? extends ListenableFuture<? extends V>> futures)：创建一个新的ListenableFuture，它的值是一个列表包含所有传入Future集合中Future执行成功后返回的值，结果的顺序与传入集合的顺序一致，如果任何一个传入集合中的Future失败或被取消，其对应的位置的值将会被设置为null，（这导致了将无法区别执行成功后返回值为null的任务）。

inCompletionOrder( Iterable<? extends ListenableFuture<? extends T>> futures)：返回一个委托的Future的列表，对应Future完成的顺序，委托的Future会返回相同的值或者抛出相同的异常，和原生的 Future一致。

addCallback(ListenableFuture<V> future, FutureCallback<? super V> callback)：注册一个在任务成功或失败时运行的回调函数，一旦Future完成，则立即执行回调函数。

addCallback(final ListenableFuture<V> future, final FutureCallback<? super V> callback, Executor executor)：注册一个在任务成功或失败时单独运行的回调函数，这个单独操作Callback的线程由传入的executor提供，一旦 Future完成，则立即执行回调函数。

get( Future<V> future, Class<X> exceptionClass)：返回Future.get()的结果，转换大部分的异常为新给定的异常类型，这样减少了大量的代码，对异常代码不必要的区分类型。

get( Future<V> future, long timeout, TimeUnit unit, Class<X> exceptionClass)：返回Future.get(long,TimeUnit)的结果，转换大部分的异常为新给定的异常类型，这样减少了大量的代码，对异常代码不必要的区分类型。

getUnchecked(Future<V> future)：返回Future.get()的结果，这个结果不会阻塞任务也不抛出被检查出的异常，这使得任务执行更轻量级，更快速运行，除非是遇到代码bug，否则不会失败。

总结：Futures是强大的操作Future的工具类，不过其中的一些方法目前自己的理解还不清晰，其中的一些方法也没有用到，还需要在以后的工作和学习中，反复思考，反复总结。学无止境。

代码地址：http://git.oschina.net/realfighter/xx566-diary/blob/master/src/guava/FuturesTest.java

转载于:https://my.oschina.net/realfighter/blog/350019