GuavaFuture 有回调函数的Future使用demo

　　谷歌的 guava 工具包和 hutool 的工具包是目前比较全而且好用的java开发工具包可以避免我们重复造轮子，最近看了下Guava的ListenableFutrue可以在线程任务执行完成之后执行我们自己编写的回调函数，从而避免了get()方法的阻塞，感觉不错，记录一下。

　　本示例使用maven作为jar包管理工具，首先在pom文件中引入guava工具包，代码如下：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
　　 <version>xxx</version>
</dependency>

PS： hutool 工具包引入示例：

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.2.0</version>
</dependency>

        首先讲一下简单的业务逻辑： 这是一个阳光明媚的早上，小明在学习编程，然后他想喝茶了。就跟管家说，你好Jenkins我想喝茶。然后就有两个仆人去做事儿了，一个人洗茶杯一个人烧水，小明继续学习。茶杯洗完了仆人会告诉小明然后把茶杯端过来，水烧开了仆人也告诉小明，把热水壶拎过来。小明暂停学习然后去快乐地泡茶喝茶。然而，仆人可能在工作的过程中出岔子，其结果也会告知小明，小明只能放弃喝茶。以下是实现代码：

　　

package com.vincent.fat.core.juc;

import cn.hutool.core.util.RandomUtil;
import com.google.common.util.concurrent.*;
import lombok.extern.slf4j.Slf4j;
import org.checkerframework.checker.nullness.compatqual.NullableDecl;
import org.jetbrains.annotations.NotNull;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
@Slf4j
public class GuavaFutureDemo {
    public static void main(String[] args) {
        Thread.currentThread().setName("主线程");
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        DrinkTeaJob drinkTeaJob=new DrinkTeaJob(executorService);
        new Thread(drinkTeaJob,"喝茶线程").start();
        Callable<Boolean> hotWaterJob = new HotWaterJob();
        Callable<Boolean> cleanCapsJob = new CleanCapsJob();
        ListeningExecutorService gpool = MoreExecutors.listeningDecorator(executorService);
        ListenableFuture<Boolean> hotFuture = gpool.submit(hotWaterJob);
        ListenableFuture<Boolean> cleanWaterFuture = gpool.submit(cleanCapsJob);
        Futures.addCallback(hotFuture, new FutureCallback<Boolean>() {
            @Override
            public void onSuccess(@NullableDecl Boolean result) {
                if (result != null) {
                    drinkTeaJob.setWaterOk(result);
                    drinkTeaJob.setWaterJobDone(true);
                }
            }
            @Override
            public void onFailure(@NotNull Throwable t) {
                drinkTeaJob.setWaterJobDone(true);
                throw new RuntimeException(t.getMessage());
            }
        },executorService);
        Futures.addCallback(cleanWaterFuture, new FutureCallback<Boolean>() {
            @Override
            public void onSuccess(@NullableDecl Boolean result) {
                if (result != null) {
                    drinkTeaJob.setCupsOk(result);
                    drinkTeaJob.setCupsJobDone(true);
                }
            }
            @Override
            public void onFailure(@NotNull Throwable t) {
                drinkTeaJob.setCupsJobDone(true);
                throw new RuntimeException(t.getMessage());
            }
        },executorService);
        log.warn("[{}]运行到最后一行代码",Thread.currentThread().getName());
    }
    static class HotWaterJob implements Callable<Boolean>{
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        @Override
        public Boolean call() throws Exception {
            TimeUnit.SECONDS.sleep(2);
            if (RandomUtil.randomBoolean()){
                log.info("水已经烧好了...");
                return true;
            }
            else {
                throw new RuntimeException("火灭了，水烧不开了。。。");
            }
        }
    }
    static class CleanCapsJob implements Callable<Boolean>{
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        @Override
        public Boolean call() throws Exception {
            TimeUnit.SECONDS.sleep(1);
            boolean res;
            if (res=RandomUtil.randomBoolean()){
                log.info("茶杯洗好了。。。。");
            }
            else {
                throw new RuntimeException("茶具摔坏了。。。");
            }
            return true;
        }
    }
    static class DrinkTeaJob implements Runnable{
        private boolean waterOk=false;

        public boolean isWaterJobDone() {
            return waterJobDone;
        }

        public void setWaterJobDone(boolean waterJobDone) {
            this.waterJobDone = waterJobDone;
        }

        public boolean isCupsJobDone() {
            return cupsJobDone;
        }

        public void setCupsJobDone(boolean cupsJobDone) {
            this.cupsJobDone = cupsJobDone;
        }

        private boolean waterJobDone=false;
        private boolean cupsJobDone=false;
        private boolean cupsOk=false;
        private final ExecutorService executorService;
        DrinkTeaJob(ExecutorService executorService){
            this.executorService=executorService;
        }
        public void setWaterOk(boolean waterOk) {
            this.waterOk = waterOk;
        }

        public void setCupsOk(boolean cupsOk) {
            this.cupsOk = cupsOk;
        }

        private int gap=0;
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see Thread#run()
         */
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted())
            {
                log.info("正在学习编程。。。");
                try{
                    TimeUnit.MILLISECONDS.sleep(this.gap);
                    if (waterJobDone&&cupsJobDone)
                    {
                        this.drinkTea();
                    }
                } catch (InterruptedException interruptedException) {
                    log.error("喝茶线程被中断了",interruptedException);
                    break;
                }
                this.gap+=500;
            }
            log.info("喝茶线程退出！！");
            this.executorService.shutdown();
        }

        private void drinkTea() throws InterruptedException {
            if (this.cupsOk&&this.waterOk)
            {
                log.info("泡茶，喝茶，苏福~~~");
            }else {
                log.warn("茶喝不成了，哭。。。。");
            }
            TimeUnit.SECONDS.sleep(1);
            Thread.currentThread().interrupt();
        }
    }
}

程序运行结果1：

程序运行结果2：