转！！JAVA Future 模式与 Promise 模式

package com.test.demo.springboottest.asynTest;

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import io.netty.util.concurrent.DefaultEventExecutorGroup;
import io.netty.util.concurrent.EventExecutorGroup;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;

import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;

/**
 * @author wuyun
 * @Description: TODO
 * @date 2020/4/22
 * @Version 1.0
 */
public class FutureTest {

    public static void main(String[] args) {

        //同步调用模式
        /*
        try {
            long l = System.currentTimeMillis();
            int i = syncCalculate();
            System.out.println("计算结果:" + i);
            System.out.println("主线程运算耗时:" + (System.currentTimeMillis() - l) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }
*/

        //Future 模式可以细分为将来式和回调式两种模式

        //1.Future 模式 – 将来式 1 (这种将来式的 future 适用多个耗时操作并发执行的场景。)
       /* try {
            long l = System.currentTimeMillis();
            EventExecutorGroup group = new DefaultEventExecutorGroup(4);
            Future<Integer> f = group.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("执行耗时操作...");
                    timeConsumingOperation();
                    return 100;
                }
            });
            // 其他耗时操作..
            System.out.println("计算结果:：" + f.get());//等待结果，线程将会被这一步阻塞
            System.out.println("主线程运算耗时:" + (System.currentTimeMillis() - l) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }*/


        //2.Future 模式 – 将来式 2---Netty框架
        //使用了 addListener 这样的方法为一个 future 结果添加回调，从而达到“当耗时操作完成后，自行触发钩子去执行打印操作”的效果。
        // 主线程只耗费了不到 1s 的时间，整个过程没有被耗时操作阻塞，这才是异步编程的推荐方式：回调。
        /*try {
            long l = System.currentTimeMillis();
            EventExecutorGroup group = new DefaultEventExecutorGroup(4);
            Future<Integer> f = group.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("执行耗时操作...");
                    timeConsumingOperation();
                    return 100;
                }
            });
            f.addListener(new GenericFutureListener<Future<? super Integer>>() {
                @Override
                public void operationComplete(Future<? super Integer> future) throws Exception {
                    System.out.println("计算结果:：" + future.get());
                }
            });

            System.out.println("主线程运算耗时:" + (System.currentTimeMillis() - l) + "ms");
            new CountDownLatch(1).await();
        } catch (Exception e) {
            e.printStackTrace();
        }*/

        //guava-异步
        /*try {
            long l = System.currentTimeMillis();
            ListeningExecutorService service= MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
            ListenableFuture<Integer> future = service.submit(new Callable<Integer>() {
                public Integer call() throws Exception {
                    System.out.println("执行耗时操作...");
                    timeConsumingOperation();
                    return 100;
                }
            });//<1>
            Futures.addCallback(future, new FutureCallback<Integer>() {
                public void onSuccess(Integer result) {
                    System.out.println("计算结果:" + result);
                }
                public void onFailure(Throwable throwable) {
                    System.out.println("异步处理失败,e=" + throwable);
                }
            });//<2>
            System.out.println("主线程运算耗时:" + (System.currentTimeMillis() - l)+ "ms");
            new CountDownLatch(1).await();
        } catch (Exception e) {
            e.printStackTrace();
        }*/


        //由 Callback Hell 引出 Promise 模式
        //jdk1.8 已经提供了一种更为高级的回调方式：CompletableFuture
        /*try {
            long l = System.currentTimeMillis();
            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("执行耗时操作...");
                timeConsumingOperation();
                return 100;
            });
            completableFuture.whenComplete((result, e) -> {
                System.out.println("结果：" + result);
            });
            System.out.println("主线程运算耗时:" + (System.currentTimeMillis() - l)+ "ms");
            new CountDownLatch(1).await();
        } catch (Exception e) {
            e.printStackTrace();
        }*/

        //回调嵌套：回调的回调
        try {
            long l = System.currentTimeMillis();
            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("在回调中执行耗时操作...");
                timeConsumingOperation();
                return 100;
            });
            // 使用 thenCompose 或者 thenComposeAsync 等方法可以实现回调的回调
            completableFuture = completableFuture.thenCompose(i -> {
                return CompletableFuture.supplyAsync(() -> {
                    System.out.println("在回调的回调中执行耗时操作...");
                    timeConsumingOperation();
                    return i + 100;
                });
            });//<1>
            completableFuture.whenComplete((result, e) -> {
                System.out.println("计算结果:" + result);
            });
            System.out.println("主线程运算耗时:" + (System.currentTimeMillis() - l) + "ms");
            new CountDownLatch(1).await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 最常用的同步调用
    static int syncCalculate() {
        System.out.println("执行耗时操作...");
        timeConsumingOperation();
        return 100;
    }
　　//耗时操作
    static void timeConsumingOperation() {
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}