【并发编程】Guava - ListenableFuture，避免Future获取阻塞问题，增加回调

已于 2023-04-07 22:29:56 修改
阅读量1.3k 收藏 4
点赞数
文章标签： 面试 guava java 职场和发展 开发语言
于 2023-03-28 16:56:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48008521/article/details/129828814
版权

1. 简介

  相比Future(【并发编程】Java5 - Future，基本使用)，Guava提供的ListenableFuture支持不阻塞主线程进行任务执行完成后的业务处理。
  使用Future的实现类FutureTask想要实现一旦获取到结果立即执行后续的业务，就需要阻塞主线程等待结果或者使用其他线程循环的判断任务是否结束，这样导致性能较低，且代码负责。ListenableFuture在Future的基础上增加了任务执行后自动调用后续业务处理的逻辑，方便我们使用。

2. ListenableFuture回调函数

  • 调用ListenableFuture接口的addListener(Runnable listener, Executor executor)方法，其中第一个参数为回调函数的处理逻辑，第二个运行监听器的线程池，一般使用执行任务的线程池
public interface ListenableFuture<V extends @Nullable Object> extends Future<V> {
  /**
   * Registers a listener to be {@linkplain Executor#execute(Runnable) run} on the given executor.
   * The listener will run when the {@code Future}'s computation is {@linkplain Future#isDone()
   * complete} or, if the computation is already complete, immediately.
   *
   * <p>There is no guaranteed ordering of execution of listeners, but any listener added through
   * this method is guaranteed to be called once the computation is complete.
   *
   * <p>Exceptions thrown by a listener will be propagated up to the executor. Any exception thrown
   * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException} or an exception
   * thrown by {@linkplain MoreExecutors#directExecutor direct execution}) will be caught and
   * logged.
   *
   * <p>Note: If your listener is lightweight -- and will not cause stack overflow by completing
   * more futures or adding more {@code directExecutor()} listeners inline -- consider {@link
   * MoreExecutors#directExecutor}. Otherwise, avoid it: See the warnings on the docs for {@code
   * directExecutor}.
   *
   * <p>This is the most general listener interface. For common operations performed using
   * listeners, see {@link Futures}. For a simplified but general listener interface, see {@link
   * Futures#addCallback addCallback()}.
   *
   * <p>Memory consistency effects: Actions in a thread prior to adding a listener <a
   * href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.4.5">
   * <i>happen-before</i></a> its execution begins, perhaps in another thread.
   *
   * <p>Guava implementations of {@code ListenableFuture} promptly release references to listeners
   * after executing them.
   *
   * @param listener the listener to run when the computation is complete
   * @param executor the executor to run the listener in
   * @throws RejectedExecutionException if we tried to execute the listener immediately but the
   *     executor rejected it.
   */
  void addListener(Runnable listener, Executor executor);
}
  • 调用Futures类的静态方法addCallback(final ListenableFuture future, final FutureCallback<? super V> callback, Executor executor)方法，其中第一个参数为任务执行后的Future，第二个为回调函数，第三个为运行回调函数的线程池，一般使用执行任务的线程池
public final class Futures extends GwtFuturesCatchingSpecialization {

  // ......

  /**
   * Registers separate success and failure callbacks to be run when the {@code Future}'s
   * computation is {@linkplain java.util.concurrent.Future#isDone() complete} or, if the
   * computation is already complete, immediately.
   *
   * <p>The callback is run on {@code executor}. There is no guaranteed ordering of execution of
   * callbacks, but any callback added through this method is guaranteed to be called once the
   * computation is complete.
   *
   * <p>Exceptions thrown by a {@code callback} will be propagated up to the executor. Any exception
   * thrown during {@code Executor.execute} (e.g., a {@code RejectedExecutionException} or an
   * exception thrown by {@linkplain MoreExecutors#directExecutor direct execution}) will be caught
   * and logged.
   *
   * <p>Example:
   *
   * <pre>{@code
   * ListenableFuture<QueryResult> future = ...;
   * Executor e = ...
   * addCallback(future,
   *     new FutureCallback<QueryResult>() {
   *       public void onSuccess(QueryResult result) {
   *         storeInCache(result);
   *       }
   *       public void onFailure(Throwable t) {
   *         reportError(t);
   *       }
   *     }, e);
   * }</pre>
   *
   * <p>When selecting an executor, note that {@code directExecutor} is dangerous in some cases. See
   * the warnings the {@link MoreExecutors#directExecutor} documentation.
   *
   * <p>For a more general interface to attach a completion listener to a {@code Future}, see {@link
   * ListenableFuture#addListener addListener}.
   *
   * @param future The future attach the callback to.
   * @param callback The callback to invoke when {@code future} is completed.
   * @param executor The executor to run {@code callback} when the future completes.
   * @since 10.0
   */
  public static <V extends @Nullable Object> void addCallback(
      final ListenableFuture<V> future,
      final FutureCallback<? super V> callback,
      Executor executor) {
    Preconditions.checkNotNull(callback);
    future.addListener(new CallbackListener<V>(future, callback), executor);
  }
  
}

3. ListenableFuture应用

  • 前期准备：实现Callable创建线程，支持指定执行时间，并增加执行时间校验逻辑
/**
 * 创建线程
 */
@RequiredArgsConstructor
class MyCallable implements Callable<Long> {

    /**
     * 任务执行时间
     */
    private final long execTime;

    @Override
    public Long call() throws Exception {
        if (execTime <= 0) {
            throw new RuntimeException("执行时间必须大于0");
        }
        log.info("任务执行，耗时：" + execTime + " ms");
        Thread.sleep(execTime);
        return execTime;
    }
}
  • 引入Guava依赖
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>
  • 增加监听器
/**
 * 增加监听器
 */
@Test
public void testAddListener() throws InterruptedException {
    ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    ListenableFuture<Long> future = listeningExecutorService.submit(new MyCallable(1000));

    // 增加监听器
    future.addListener(new Runnable() {
        @Override
        public void run() {
            try {
                log.info("任务执行结束，结果为：" + future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }, listeningExecutorService);

    // 为了验证测试结果，阻塞主线程，等待监听器任务异步执行
    // 真实使用不需要阻塞主线程
    Thread.sleep(3000);
    listeningExecutorService.shutdown();
}

  控制台打印：

19:18:29.256 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：1000 ms
19:18:30.263 [pool-1-thread-2] INFO com.c3stones.test.ListenableFutureTest - 任务执行结束，结果为：1000
  • 测试任务执行成功回调
/**
 * 测试任务执行成功回调
 */
@Test
public void addCallbackOfSuccess() throws InterruptedException {
    ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    ListenableFuture<Long> future = listeningExecutorService.submit(new MyCallable(1000));

    // 增加回调
    FutureCallback<Long> futureCallback = new FutureCallback<Long>() {

        /**
         * 成功时调用
         * @param result
         */
        @Override
        public void onSuccess(Long result) {
            try {
                log.info("任务执行成功，结果为：" + future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        /**
         * 失败时调用
         * @param t
         */
        @Override
        public void onFailure(Throwable t) {
            log.error("任务执行失败，异常原因：" + t.getMessage());
        }

    };

    Futures.addCallback(future, futureCallback, listeningExecutorService);

    // 为了验证测试结果，阻塞主线程，等待监听器任务异步执行
    // 真实使用不需要阻塞主线程
    Thread.sleep(3000);
    listeningExecutorService.shutdown();
}

  控制台打印：

19:19:34.162 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：1000 ms
19:19:35.173 [pool-1-thread-2] INFO com.c3stones.test.ListenableFutureTest - 任务执行成功，结果为：1000
  • 测试任务执行失败回调
/**
 * 测试任务执行失败回调
 */
@Test
public void addCallbackOfFailure() throws InterruptedException {
    ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    ListenableFuture<Long> future = listeningExecutorService.submit(new MyCallable(-1));

    // 增加回调
    FutureCallback<Long> futureCallback = new FutureCallback<Long>() {

        /**
         * 成功时调用
         * @param result
         */
        @Override
        public void onSuccess(Long result) {
            try {
                log.info("任务执行成功，结果为：" + future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        /**
         * 失败时调用
         * @param t
         */
        @Override
        public void onFailure(Throwable t) {
            log.error("任务执行失败，异常原因：" + t.getMessage());
        }

    };

    Futures.addCallback(future, futureCallback, listeningExecutorService);

    // 为了验证测试结果，阻塞主线程，等待监听器任务异步执行
    // 真实使用不需要阻塞主线程
    Thread.sleep(3000);
    listeningExecutorService.shutdown();
}

  控制台打印：

19:21:29.158 [pool-1-thread-1] ERROR com.c3stones.test.ListenableFutureTest - 任务执行失败，异常原因：执行时间必须大于0
  • 测试所有任务执行成功并获取结果集
/**
 * 测试所有任务执行成功并获取结果集
 *
 * @throws InterruptedException
 */
@Test
public void testAsListSuccess() throws InterruptedException {
    ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    // 创建3个任务，3个都成功
    ListenableFuture<Long> future1 = listeningExecutorService.submit(new MyCallable(1000));
    ListenableFuture<Long> future2 = listeningExecutorService.submit(new MyCallable(2000));
    ListenableFuture<Long> future3 = listeningExecutorService.submit(new MyCallable(3000));

    ListenableFuture<List<Long>> future = Futures.allAsList(future1, future2, future3);

    // 增加回调
    FutureCallback<List<Long>> futureCallback = new FutureCallback<List<Long>>() {

        /**
         * 成功时调用
         * @param result
         */
        @Override
        public void onSuccess(List<Long> result) {
            try {
                log.info("任务执行成功，结果为：" + future.get().stream().map(String::valueOf).collect(Collectors.joining(",")));
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        /**
         * 失败时调用
         * @param t
         */
        @Override
        public void onFailure(Throwable t) {
            log.error("任务执行失败，异常原因：" + t.getMessage());
        }

    };

    Futures.addCallback(future, futureCallback, listeningExecutorService);

    // 为了验证测试结果，阻塞主线程，等待监听器任务异步执行
    // 真实使用不需要阻塞主线程
    Thread.sleep(5000);
    listeningExecutorService.shutdown();
}

  控制台打印：

20:11:13.057 [pool-1-thread-2] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：2000 ms
20:11:13.051 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：1000 ms
20:11:13.059 [pool-1-thread-3] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：3000 ms
20:11:16.063 [pool-1-thread-2] INFO com.c3stones.test.ListenableFutureTest - 任务执行成功，结果为：1000,2000,3000
  • 测试包含失败任务执行并获取结果集
/**
 * 测试包含失败任务执行并获取结果集
 *
 * @throws InterruptedException
 */
@Test
public void testAsListFailure() throws InterruptedException {
    ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    // 创建3个任务，2个都成功，1个失败
    ListenableFuture<Long> future1 = listeningExecutorService.submit(new MyCallable(1000));
    ListenableFuture<Long> future2 = listeningExecutorService.submit(new MyCallable(-2));
    ListenableFuture<Long> future3 = listeningExecutorService.submit(new MyCallable(3000));

    ListenableFuture<List<Long>> future = Futures.allAsList(future1, future2, future3);

    // 增加回调
    FutureCallback<List<Long>> futureCallback = new FutureCallback<List<Long>>() {

        /**
         * 成功时调用
         * @param result
         */
        @Override
        public void onSuccess(List<Long> result) {
            try {
                log.info("任务执行成功，结果为：" + future.get().stream().map(String::valueOf).collect(Collectors.joining(",")));
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        /**
         * 失败时调用
         * @param t
         */
        @Override
        public void onFailure(Throwable t) {
            log.error("任务执行失败，异常原因：" + t.getMessage());
        }

    };

    Futures.addCallback(future, futureCallback, listeningExecutorService);

    // 为了验证测试结果，阻塞主线程，等待监听器任务异步执行
    // 真实使用不需要阻塞主线程
    Thread.sleep(5000);
    listeningExecutorService.shutdown();
}

  控制台打印：

20:12:51.029 [pool-1-thread-3] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：3000 ms
20:12:51.030 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：1000 ms
20:12:51.091 [pool-1-thread-2] ERROR com.c3stones.test.ListenableFutureTest - 任务执行失败，异常原因：执行时间必须大于0

  通过结果可以看出，只要有任务失败，则不会执行回调方法中成功的处理逻辑，而是仅执行回调方法中失败的处理逻辑。适用于任务不会失败，或者专门获取任意失败任务时的场景。

  • 测试所有任务执行成功或失败获取结果，失败结果替换为null
/**
 * 测试所有任务执行成功或失败获取结果，失败结果替换为null
 *
 * @throws InterruptedException
 */
@Test
public void testSuccessfulAsList() throws InterruptedException {
    ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    // 创建3个任务，2个都成功，1个失败
    ListenableFuture<Long> future1 = listeningExecutorService.submit(new MyCallable(1000));
    ListenableFuture<Long> future2 = listeningExecutorService.submit(new MyCallable(-2));
    ListenableFuture<Long> future3 = listeningExecutorService.submit(new MyCallable(3000));

    ListenableFuture<List<Long>> future = Futures.successfulAsList(future1, future2, future3);

    // 增加回调
    FutureCallback<List<Long>> futureCallback = new FutureCallback<List<Long>>() {

        /**
         * 成功时调用
         * @param result
         */
        @Override
        public void onSuccess(List<Long> result) {
            try {
                log.info("任务执行成功，结果为：" + future.get().stream().map(String::valueOf).collect(Collectors.joining(",")));
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        /**
         * 失败时调用
         * @param t
         */
        @Override
        public void onFailure(Throwable t) {
            log.error("任务执行失败，异常原因：" + t.getMessage());
        }

    };

    Futures.addCallback(future, futureCallback, listeningExecutorService);

    // 为了验证测试结果，阻塞主线程，等待监听器任务异步执行
    // 真实使用不需要阻塞主线程
    Thread.sleep(5000);
    listeningExecutorService.shutdown();
}

  控制台打印：

20:16:10.092 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：1000 ms
20:16:10.092 [pool-1-thread-3] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：3000 ms
20:16:13.104 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行成功，结果为：1000,null,3000
  • 测试返回结果同步转换
/**
 * 测试返回结果同步转换
 */
@Test
public void testTransform() throws InterruptedException {
    ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    ListenableFuture<Long> future1 = listeningExecutorService.submit(new MyCallable(1000));

    // 将返回结果转换为字符串
    ListenableFuture<String> transform = Futures.transform(future1, new Function<Long, String>() {

        @Override
        public String apply(Long input) {
            String result = String.valueOf(input);
            log.info("将Long[" + input + "] 转换为 String[" + result + "]");
            return "String -> " + result;
        }

    }, listeningExecutorService);

    // 增加回调
    FutureCallback<String> futureCallback = new FutureCallback<String>() {

        /**
         * 成功时调用
         * @param result
         */
        @Override
        public void onSuccess(String result) {
            log.info("任务执行成功，结果为：" + result);
        }

        /**
         * 失败时调用
         * @param t
         */
        @Override
        public void onFailure(Throwable t) {
            log.error("任务执行失败，异常原因：" + t.getMessage());
        }

    };

    Futures.addCallback(transform, futureCallback, listeningExecutorService);

    // 为了验证测试结果，阻塞主线程，等待监听器任务异步执行
    // 真实使用不需要阻塞主线程
    Thread.sleep(3000);
    listeningExecutorService.shutdown();
}

  控制台打印：

20:40:11.661 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：1000 ms
20:40:12.830 [pool-1-thread-2] INFO com.c3stones.test.ListenableFutureTest - 将Long[1000] 转换为 String[1000]
20:40:12.832 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行成功，结果为：String -> 1000
  • 测试返回结果异步转换
/**
 * 测试返回结果异步转换
 */
@Test
public void testTransformAsync() throws InterruptedException {
    ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    ListenableFuture<Long> future1 = listeningExecutorService.submit(new MyCallable(1000));

    // 将返回结果转换为字符串
    ListenableFuture<String> transform = Futures.transformAsync(future1, new AsyncFunction<Long, String>() {

        @Override
        public ListenableFuture<String> apply(Long input) throws Exception {
            String result = String.valueOf(input);
            log.info("将Long[" + input + "] 转换为 String[" + result + "]");
            return Futures.immediateFuture("String -> " + result);
        }

    }, listeningExecutorService);

    // 增加回调
    FutureCallback<String> futureCallback = new FutureCallback<String>() {

        /**
         * 成功时调用
         * @param result
         */
        @Override
        public void onSuccess(String result) {
            log.info("任务执行成功，结果为：" + result);
        }

        /**
         * 失败时调用
         * @param t
         */
        @Override
        public void onFailure(Throwable t) {
            log.error("任务执行失败，异常原因：" + t.getMessage());
        }

    };

    Futures.addCallback(transform, futureCallback, listeningExecutorService);

    // 为了验证测试结果，阻塞主线程，等待监听器任务异步执行
    // 真实使用不需要阻塞主线程
    Thread.sleep(3000);
    listeningExecutorService.shutdown();
}

  控制台打印：

20:42:02.687 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行，耗时：1000 ms
20:42:03.697 [pool-1-thread-2] INFO com.c3stones.test.ListenableFutureTest - 将Long[1000] 转换为 String[1000]
20:42:03.699 [pool-1-thread-1] INFO com.c3stones.test.ListenableFutureTest - 任务执行成功，结果为：String -> 1000

4. 项目地址

  thread-demo

C3Stones
关注
一句话ListenableFuture简介
悟已往之不谏，知来者之可追
11-16 1326
ListenableFuture 并发是一个难问题，但是通过强有力和简单的抽象，可以简化。为了使问题简化，Guava 使用了JDK 的ListenableFuture接口。 这里强烈推荐诸位使用ListenableFuture而不是Future。原因有如下三点： 大多数的Future方法需要ListenableFuture 切换到ListenableFuture很容易 工具方法的提供者不需要...
Guava - 并行编程Futures详解
09-01
Guava的并行编程Futures是Java并发处理的重要工具，它极大地增强了标准Java中的Future接口。Future接口在Java中主要用于异步计算的结果表示，而Guava的ListenableFuture则在此基础上增加了一个重要的特性：监听器...
JAVA的异步（2）：guava-ListenableFuture
SGT的博客
08-17 876
JAVA异步实现（2）：guava-ListenableFutureListenableFutureFutureCallbackSettableFuture 在JDK1.8之前，java官方一直没有提供比Future更好的异步工具（Future相关在前一篇博客中有介绍），为此google的guava库中提供了ListenableFuture作为Future的工具，在JDK1.8中增加了CompletableFuture作为对Future的补充，见下一篇博客。 本文的maven依赖如下： <depen
ListenableFuture的使用和原理
热门推荐
帅东's Blog
10-31 2万+
java中有几种实现异步的方式(FutureTask/ListenableFuture/CompletableFuture) 这篇介绍的是ListenableFuture，相比FutureTask，本质上只是增加了任务的回调函数，这个是google框架里面的一个东西，我用的版本是guava-27.0-jre.jar 首先还是说使用： public class ListenableFutureTes...
浅析ListenableFuture使用场景及介绍示例
石头视角
04-28 1万+
ListenableFuture是对原有Future的增强，可以用于监听Future任务的执行状况，是执行成功还是执行失败，并提供响应的接口用于对不同结果的处理。 适用场景： 1、如果一个主任务开始执行，然后需要执行各个小任务，并且需要等待返回结果，统一返回给前端，此时Future和ListenableFuture作用几乎差不多，都是通过get()方法阻塞等待每个任务执行完毕返回。
Guava线程池介绍
qq_36042938的博客
10-20 4172
简介 ListenableFuture顾名思义就是可以监听的Future，它是对java原生Future的扩展增强。我们知道Future表示一个异步计算任务，当任务完成时可以得到计算结果。如果我们希望一旦计算完成就拿到结果展示给用户或者做另外的计算，就必须使用另一个线程不断的查询计算状态。这样做，代码复杂，而且效率低下。使用ListenableFuture Guava帮我们检测Future是否完成了，如果完成就自动调用回调函数，这样可以减少并发程序的复杂度。 推............
ListenableFuture
qq_36109365的博客
12-14 1232
ListenableFuture顾名思义就是可以监听的Future，它是对java原生Future的扩展增强。我们知道Future表示一个异步计算任务，当任务完成时可以得到计算结果。如果我们希望一旦计算完成就拿到结果展示给用户或者做另外的计算，就必须使用另一个线程不断的查询计算状态。这样做，代码复杂，而且效率低下。使用ListenableFuture Guava帮我们检测Future是否完成了，如
guava-API文档
08-03
3. 并发工具：Guava提供了一套强大的并发工具，包括Future、Service、ListenableFuture、ExecutorService等，它们使得异步编程和任务管理更加容易和高效。例如，ListenableFuture接口允许添加回调函数，当异步操作...
future:Java、Guava 和 Scala 中的 Furures 和 promise
06-14
`ListenableFuture.addCallback()` 方法允许我们注册回调函数，这样当 Future 完成时（无论成功还是失败），回调函数都会被调用。这为异步编程提供了更加灵活的事件驱动模型。 Scala 的 Futures 和 Promises 则是其...
Async-http-client
11-26
这意味着发送请求不会阻塞当前线程，而是立即返回，当请求完成时通过回调函数通知用户，这种模型特别适合于高并发环境。 2. **非阻塞I/O**：利用NIO（New IO）技术，Async-http-client能够有效地管理多个并发连接，...
如何利用Java开发高性能、高并发Web应用
04-19
4. **异步编程与回调**： 使用Future和Callable接口，配合ExecutorService，可以实现异步计算，释放主线程资源。Java 8引入了CompletableFuture，进一步简化了异步编程，支持链式调用和回调。 5. **响应式编程**：...
那些年我们追过的异步骚操作：ListenableFuture、CompletableFuture、RxJava(Observable)
布道
03-13 6336
Futures在Java 5(2004)中引入。它们是承诺在操作完成后保留操作结果的对象。调用者可以使用future对象来检查操作isDone()，或者等待它完成使用get()。Future模式一个最大的问题是何时调用问题（过早地阻塞Future.get()，这消除了异步执行的好处）。guava的 ListenableFuture、java8的CompletableFuture、RxJava的...
Spring番外篇-ListenableFuture
zzzj的博客
04-08 846
其实更好的方式是给future添加一个listener，成功或者异常后回调listener。，因为功能非常强大，性能也很优秀，Doug Lea大神对其的优化无所不用其极。这个线程池定义了两个方法返回ListenableFuture。什么情况下该使用ListenableFuture。就对原生的Future做了增强，提供了。(redis客户端)就大量地使用了。诞生于Spring4.0，晚于。在Spring团队后面创造的。，当时Netty4也晚于。所以Spring创造了。其他情况下都更推荐使用。
Guava入门~FutureCallback
小强快跑~~
08-19 797
如果提供的FutureCallback实例，将执行耗时的操作，建议调用如下方法。这样FutureCallback的操作，将会在一个新线程中执行。
先进的ListenableFuture功能
最佳 Java 编程
05-14 679
上次我们熟悉了ListenableFuture 。 我答应介绍更高级的技术，即转换和链接。 让我们从简单的事情开始。 假设我们有从某些异步服务获得的ListenableFuture<String> 。 我们还有一个简单的方法： Document parse(String xml) {//... 我们不需要String ，我们需要Document 。 一种方法是简单地解析Fut...
使用ListenableFuture进行异步任务执行并进行线程切换
最新发布
Mr_Tony的专栏
11-23 1141
在程序中会经常需要做一些异步任务，但是由于部分操作其实很简单，仅仅是短暂的进行异步操作，然后在结果成功或失败的时候切换回主线程进行下一步处理，这期间不能阻塞主线程。这里记录一下使用google的guava库里面的并发类进行处理，也可以，只是在Android上最低支持API23版本，但是项目最低支持21。使用来进行Java高版本兼容的话，改动比较多，一直有R8/D8兼容性错误。估计要升级jdk、gradle等等版本，在协作开发中不太合适。项目中本身就有guava。所以使用这个进行开发。
Google 的核心 Java 库 guava 常用工具类
蚩尤后裔-汪茂雄
07-25 1万+
目录 com.google.common.collect.Lists 工具类 com.google.common.primitives.Ints 整形操作 com.google.common.collect.Multiset Multimap 提供一个 key 对多个值 连接器 Joiner、分割器 Splitter 字符匹配器：CharMatcher com.google.comm...
Guava异步编程之ListenableFuture
qq_41030039的博客
01-11 2389
前提：Java的Future虽然已经提供异步操作，但是不能直接回调。Guava对Future进行了增强，核心接口就是ListenableFuture。 一、ListenableFuture源码解析 guava对JDK的异步增强可以通过看MoreExecutor和Futures两个类的源码入手。 ListenableFuture继承了Future，额外新增了一个方法，listener是任务结束后...
Duplicate class com.google.common.util.concurrent.ListenableFuture found in modules jetified-guava-24.0-android (com.google.guava:guava:24.0-android) and jetified-listenablefuture-1.0 (com.google.guava:listenablefuture:1.0)
05-24
要解决这个问题，你需要在你的项目中排除其中一个模块的 `ListenableFuture` 类。可以在 `build.gradle` 文件中添加以下代码： ``` dependencies { // ... implementation('com.google.guava:guava:24.0-android'...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值