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>() {  26  @Override  27             public void onSuccess(@NullableDecl Boolean result) {  28                 if (result != null) {  29  drinkTeaJob.setWaterOk(result);  30                     drinkTeaJob.setWaterJobDone(true);  31  }  32  }  33  @Override  34             public void onFailure(@NotNull Throwable t) {  35                 drinkTeaJob.setWaterJobDone(true);  36                 throw new RuntimeException(t.getMessage());  37  }  38  },executorService);  39         Futures.addCallback(cleanWaterFuture, new FutureCallback<Boolean>() {  40  @Override  41             public void onSuccess(@NullableDecl Boolean result) {  42                 if (result != null) {  43  drinkTeaJob.setCupsOk(result);  44                     drinkTeaJob.setCupsJobDone(true);  45  }  46  }  47  @Override  48             public void onFailure(@NotNull Throwable t) {  49                 drinkTeaJob.setCupsJobDone(true);  50                 throw new RuntimeException(t.getMessage());  51  }  52  },executorService);  53         log.warn("[{}]運行到最后一行代碼",Thread.currentThread().getName());
 }  55     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：