Netty入门——Future和Promise接口

一、Future & Promise的概述

1.1、Future & Promise的说明

netty 中的 Future 与 jdk 中的 Future 同名，但是是两个接口，netty 的 Future 继承自 jdk 的 Future，而 Promise 又对 netty Future 进行了扩展

• jdk Future 只能同步等待任务结束（或成功、或失败）才能得到结果
• netty Future 可以同步等待任务结束得到结果，也可以异步方式得到结果，但都是要等任务结束
• netty Promise 不仅有 netty Future 的功能，而且脱离了任务独立存在，只作为两个线程间传递结果的容器

1.2、Future & Promise的说明列表

二、jdk 的 Future代码示例

• 示例代码

  import lombok.extern.slf4j.Slf4j;
  import java.util.concurrent.*;
  /**
   * @description: jdk 的 Future示例
   * @author: xz
   */
  @Slf4j
  public class JdkFutureTest {
      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.debug("执行计算");
                  Thread.sleep(1000);
                  return 50;
              }
          });
          // 3. 主线程通过 future 来获取结果
          log.debug("等待结果");
          log.debug("结果是 {}", future.get());
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25

• 输出结果
  

三、netty 的 Future代码示例

3.1、同步接收结果代码示例

• 示例代码

  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;
  
  /**
   * @description: netty 的 Future示例
   * @author: xz
   */
  @Slf4j
  public class NettyFutureTest {
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          getResult1();
      }
      /**
       * 同步接收结果
       * */
      public static void getResult1() throws InterruptedException, ExecutionException {
          // 1. 准备 EventLoop 对象
          NioEventLoopGroup group = new NioEventLoopGroup();
          EventLoop eventLoop = group.next();
          // 2. 提交任务
          Future<Integer> future = eventLoop.submit(new Callable<Integer>() {
              @Override
              public Integer call() throws Exception {
                  log.debug("执行计算");
                  Thread.sleep(1000);
                  return 70;
              }
          });
          // 3. 同步接收结果（即主线程通过 future 来获取结果）
          log.debug("等待结果");
          log.debug("结果是 {}", future.get());
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38

• 输出结果
  

3.2、异步接收结果代码示例

• 示例代码

  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;
  
  /**
   * @description: netty 的 Future示例
   * @author: xz
   */
  @Slf4j
  public class NettyFutureTest {
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          getResult2();
      }
      /**
       * 异步接收结果
       * */
      public static void getResult2() throws InterruptedException {
          // 1. 准备 EventLoop 对象
          NioEventLoopGroup group = new NioEventLoopGroup();
          EventLoop eventLoop = group.next();
          // 2. 提交任务
          Future<Integer> future = eventLoop.submit(new Callable<Integer>() {
              @Override
              public Integer call() throws Exception {
                  log.debug("执行计算");
                  Thread.sleep(1000);
                  return 70;
              }
          });
  
          //3. 异步接收结果
          future.addListener(new GenericFutureListener<Future<? super Integer>>(){
              @Override
              public void operationComplete(Future<? super Integer> future) throws Exception {
                  log.debug("接收结果:{}", future.getNow());
              }
          });
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43

• 输出结果
  

四、netty 的 Promise代码示例

4.1、获取成功结果代码示例

• 示例代码

  import io.netty.channel.EventLoop;
  import io.netty.channel.nio.NioEventLoopGroup;
  import io.netty.util.concurrent.DefaultPromise;
  import lombok.extern.slf4j.Slf4j;
  import java.util.concurrent.ExecutionException;
  
  /**
   * @description: netty的Promise示例
   * @author: xz
   */
  @Slf4j
  public class NettyPromiseTest {
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          getSuccessResult();
      }
      /**
       *获取成功结果
       * */
      public static void getSuccessResult() throws InterruptedException, ExecutionException {
          // 1. 准备 EventLoop 对象
          EventLoop eventLoop = new NioEventLoopGroup().next();
          // 2. 可以主动创建 promise, 结果容器
          DefaultPromise<Integer> promise = new DefaultPromise<>(eventLoop);
          new Thread(() -> {
              // 3. 任意一个线程执行计算，计算完毕后向 promise 填充结果
              log.debug("开始计算...");
              try {
                  Thread.sleep(1000);
                  promise.setSuccess(80);
              } catch (Exception e) {
                  e.printStackTrace();
                  promise.setFailure(e);
              }
  
          }).start();
          // 4. 接收结果的线程
          log.debug("等待结果...");
          log.debug("结果是: {}", promise.get());
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40

• 输出结果
  

4.2、获取异常结果代码示例

• 示例代码

  import io.netty.channel.EventLoop;
  import io.netty.channel.nio.NioEventLoopGroup;
  import io.netty.util.concurrent.DefaultPromise;
  import lombok.extern.slf4j.Slf4j;
  import java.util.concurrent.ExecutionException;
  
  /**
   * @description: netty的Promise示例
   * @author: xz
   */
  @Slf4j
  public class NettyPromiseTest {
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          getExceptionResult();
      }
      /**
       *获取异常结果
       * */
      public static void getExceptionResult() throws InterruptedException, ExecutionException {
          // 1. 准备 EventLoop 对象
          EventLoop eventLoop = new NioEventLoopGroup().next();
          // 2. 可以主动创建 promise, 结果容器
          DefaultPromise<Integer> promise = new DefaultPromise<>(eventLoop);
          new Thread(() -> {
              // 3. 任意一个线程执行计算，计算完毕后向 promise 填充结果
              log.debug("开始计算...");
              try {
                  int i = 1 / 0;
                  Thread.sleep(1000);
                  promise.setSuccess(80);
              } catch (Exception e) {
                  e.printStackTrace();
                  promise.setFailure(e);
              }
  
          }).start();
          // 4. 接收结果的线程
          log.debug("等待结果...");
          log.debug("结果是: {}", promise.get());
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41

• 输出结果