轉！！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();
        }
    }

}

 

 原博文地址：https://www.cnkirito.moe/future-and-promise/