Guava Future

朱雀 2020-10-11 13:32 1026阅读 0赞

Guava Future 能够 **减少主函数的等待时间，使得多任务能够异步非阻塞执行**

ListenableFuture是可以监听的Future，它是对java原生Future的扩展增强。Future表示一个异步计算任务，当任务完成时可以得到计算结果。如果希望计算完成时马上就拿到结果展示给用户或者做另外的计算，就必须使用另一个线程不断的查询计算状态。这样做会使得代码复杂，且效率低下。如果使用ListenableFuture，Guava会帮助检测Future是否完成了，如果完成就自动调用回调函数，这样可以减少并发程序的复杂度。

还是那句话，废话不多说，直接上代码：

package com.aplus.controller;
    
    import com.google.common.util.concurrent.*;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Random;
    import java.util.concurrent.Callable;
    import java.util.concurrent.Executors;
    
    /**
     * @author whb
     */
    @Slf4j
    @RestController
    @RequestMapping(value = "/api/guava")
    public class GuavaController {
        
        public static final ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
    
        public static void main(String[] args) {
            long start = System.currentTimeMillis();
    
            // 任务1
            ListenableFuture<Boolean> booleanTask = service.submit(new Callable<Boolean>() {
                @Override
                public Boolean call() throws Exception {
                    Thread.sleep(10000);
                    return true;
                }
            });
    
            Futures.addCallback(booleanTask, new FutureCallback<Boolean>() {
                @Override
                public void onSuccess(Boolean result) {
                    System.out.println("BooleanTask.任务1-10s: " + result);
                }
    
                @Override
                public void onFailure(Throwable throwable) {
                    System.out.println("BooleanTask.throwable: " + throwable);
                }
            });
    
            // 任务2
            ListenableFuture<String> stringTask = service.submit(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    Thread.sleep(3000);
                    return "Hello World";
                }
            });
    
            Futures.addCallback(stringTask, new FutureCallback<String>() {
                @Override
                public void onSuccess(String result) {
                    System.out.println("StringTask.任务2-3s: " + result);
                }
    
                @Override
                public void onFailure(Throwable t) {
                }
            });
    
            // 任务3
            ListenableFuture<Integer> integerTask = service.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    Thread.sleep(2000);
                    return new Random().nextInt(100);
                }
            });
    
            Futures.addCallback(integerTask, new FutureCallback<Integer>() {
                @Override
                public void onSuccess(Integer result) {
                    System.err.println("IntegerTask.任务3-2s：: " + result);
                }
    
                @Override
                public void onFailure(Throwable t) {
                }
            });
    
            // 执行时间
            System.err.println("time: " + (System.currentTimeMillis() - start));
        }
    
    }

解释一波：

启动一个线程池，有三个线程和三个任务，分别是线程1，线程2，线程3；线程1执行任务1（耗时10s），线程2执行任务2（耗时3s），线程3执行任务3（耗时2s）；

Thread1  ——> Task1  10s
    Thread2  ——> Task2  2s
    Thread3  ——> Task3  3s

我们运行程序看效果：

![20190521103359624.png][]

这里我们可以看到，每一个任务下面，都去获取任务的结果，从代码来看，任务1执行时间是10s，任务2是3s，任务3是2s，虽然代码里是任务1先执行的，但是从打印结果来看，是执行时间最少的先打印，执行时间最长的是最后打印，说明它获取结果时，只要结果有反馈，就能获取到，因为它是非阻塞的。

[JDK.Future.get_ _]

[20190521103359624.png]: /images/1602423102234.png