1 jdk中的Future是通过提交线程池任务返回的任务执行结果，并且，Jdk的Future只能同步的获取结果；代码如下：

package com.study.nio.ph2.e3;import lombok.extern.slf4j.Slf4j;import java.util.concurrent.*;/** * @program: isc-study * @description: jdkFuture测试 jdkFuture只能同步的获取结果 * @author: wangjinwei * @create: 2021-10-27 09:35 **/@Slf4j@SuppressWarnings("all")public class TestJdkFuture {    public static void main(String[] args) throws ExecutionException, InterruptedException {        // 1 线程池返回        ExecutorService service = Executors.newFixedThreadPool(2);        // 2 提交任务        Future<Integer> future = service.submit(new Callable<Integer>() {            @Override            public Integer call() throws Exception {                log.info("获取操作结果中");                Thread.sleep(1000);                return 10;            }        });        // 3 主线程同步获取操作结果        Integer result = future.get();        log.info("结果是 {}", result);    }}

jdkFuture只能同步的获取结果

2 Netty的Future与jdk的 Future相比较，多了一个异步接收结果的方式，就是Future.addListener方法

package com.study.nio.ph2.e3;import io.netty.channel.EventLoop;import io.netty.channel.nio.NioEventLoopGroup;import io.netty.util.concurrent.Future;import io.netty.util.concurrent.GenericFutureListener;import lombok.extern.slf4j.Slf4j;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;/** * @program: isc-study * * @description: Netty的Future与jdk的 Future相比较，多了一个异步接收结果的方式 * * @author: wangjinwei * * @create: 2021-10-27 10:02 **/@Slf4jpublic class TestNettyFuture {    public static void main(String[] args) throws ExecutionException, InterruptedException {        NioEventLoopGroup group = new NioEventLoopGroup();        //获取一个事件循环        EventLoop eventLoop = group.next();        Future<Integer> submit = eventLoop.submit(new Callable<Integer>() {            @Override            public Integer call() throws Exception {                log.info("加载中。。。。");                Thread.sleep(1000);                return 100;            }        });/*        log.info("等待结果");        //1 主线程想获得结果  同步的方式        log.info("主线程想获得结果：{}",submit.get());*/        //2 主线程异步的方式获取结果        submit.addListener(new GenericFutureListener<Future<? super Integer>>() {            @Override            public void operationComplete(Future<? super Integer> future) throws Exception {                //异步方式接收结果                log.info("异步方式接收结果  {}", future.getNow());            }        });    }}

Netty的Future同步获得结果

Netty的Future异步方式接收结果

3 Netty 中的Promise 与 Future相比较多了一个自己设置结果的方式，前面的jdkFutre、NettyFuture它们都是通过提交任务的形式创建的，并不是自己new 一个Future对象，而Promise具有他们两的功能，可以new 的方式创建 代码如下：

package com.study.nio.ph2.e3;import io.netty.channel.EventLoop;import io.netty.channel.nio.NioEventLoopGroup;import io.netty.util.concurrent.DefaultProgressivePromise;import io.netty.util.concurrent.DefaultPromise;import lombok.SneakyThrows;import lombok.extern.slf4j.Slf4j;import java.util.concurrent.ExecutionException;/** * @program: isc-study * * @description: 前面的jdk Futue 和 netty Future 都是往线程池中提交任务然后返回的，不是自己创建的 promise可以主动创建 * * @author: wangjinwei * * @create: 2021-10-27 10:55 **/@Slf4jpublic class TestNettyPromise {    public static void main(String[] args) throws ExecutionException, InterruptedException {        // 1准备eventLoop对象        EventLoop eventLoop = new NioEventLoopGroup().next();        //可以主动创建 ,结果容器，线程执行结束了，可以把结果装里头        DefaultPromise<Integer> promise = new DefaultProgressivePromise<>(eventLoop);        new Thread(() -> {            log.info("任务执行中。。。。。");            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();                //可以带出结果                promise.setFailure(e);            }            //任务结束后填充结果            promise.setSuccess(100);        }).start();        //主线程获取结果        log.info("结果是 {}", promise.get());        // 设置回调，异步接收结果/*        promise.addListener(future -> {            // 这里的 future 就是上面的 promise            log.debug("{}",future.getNow());        });*/    }}

netty promise 运行结果