Netty 基础-组件之Future & Promise

已于 2022-11-05 18:24:26 修改
阅读量358 收藏 1
点赞数
分类专栏： netty 文章标签： java netty
于 2021-09-09 17:33:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42764269/article/details/119946670
版权

3. 组件

3.3 Future & Promise

在异步处理时，经常用到这两个接口

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

  • jdk Future 只能同步等待任务结束（或成功、或失败）才能得到结果
  • netty Future 可以同步等待任务结束得到结果，也可以异步方式得到结果，但都是要等任务结束
  • netty Promise 不仅有 netty Future 的功能，而且脱离了任务独立存在，只作为两个线程间传递结果的容器
功能/名称jdk Futurenetty FuturePromise
cancel取消任务--
isCanceled任务是否取消--
isDone任务是否完成，不能区分成功失败--
get获取任务结果，阻塞等待--
getNow-获取任务结果，非阻塞，还未产生结果时返回 null-
await-等待任务结束，如果任务失败，不会抛异常，而是通过 isSuccess 判断-
sync-等待任务结束，如果任务失败，抛出异常-
isSuccess-判断任务是否成功-
cause-获取失败信息，非阻塞，如果没有失败，返回null-
addLinstener-添加回调，异步接收结果-
setSuccess--设置成功结果
setFailure--设置失败结果

3.3.1 jdk Future 简单示例

/**
 * @author chenxc
 * @date 2021/8/25 21:57
 */
@Slf4j
public class TestJdkFuture {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建线程池
        final ExecutorService service = Executors.newFixedThreadPool(2);
        //2.提交任务
        final Future<Integer> future = service.submit(() -> {
            log.debug("开始计算");
            Thread.sleep(1000);
            log.debug("计算完成");
            return 50;
        });
        log.debug("等待结果");
        //3.主线程通过future来获取结果
        log.debug("结果是 {}",future.get());
    }
}

输出

15:52:31 [DEBUG] [main] c.i.n.c.TestJdkFuture - 等待结果
15:52:31 [DEBUG] [pool-1-thread-1] c.i.n.c.TestJdkFuture - 开始计算
15:52:32 [DEBUG] [pool-1-thread-1] c.i.n.c.TestJdkFuture - 计算完成
15:52:32 [DEBUG] [main] c.i.n.c.TestJdkFuture - 结果是 50

3.3.2 Netty Future 简单示例

/**
 * @author chenxc
 * @date 2021/8/25 22:10
 */
@Slf4j
public class TestNettyFuture {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();
        final EventLoop eventLoop = group.next();
        final Future<Integer> future = eventLoop.submit(() -> {
            log.debug("开始计算");
            Thread.sleep(1000);
            log.debug("计算完成");
            return 70;
        });
        // 同步 1
        log.debug("等待结果");
        //log.debug("结果是 {}",future.get());
        // 同步 2
        /*future.sync();
        log.debug("结果是 {}",future.getNow());*/
        // 异步
        future.addListener(future1 -> {
            log.debug("结果是 {}",future.getNow());
        });
    }
}

输出

15:53:27 [DEBUG] [main] c.i.n.c.TestNettyFuture - 等待结果
15:53:27 [DEBUG] [nioEventLoopGroup-2-1] c.i.n.c.TestNettyFuture - 开始计算
15:53:28 [DEBUG] [nioEventLoopGroup-2-1] c.i.n.c.TestNettyFuture - 计算完成
15:53:28 [DEBUG] [nioEventLoopGroup-2-1] c.i.n.c.TestNettyFuture - 结果是 70

3.3.3 Netty Pomise 示例

3.3.3.1 同步处理任务成功
DefaultEventLoop eventExecutors = new DefaultEventLoop();
DefaultPromise<Integer> promise = new DefaultPromise<>(eventExecutors);

eventExecutors.execute(()->{
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.debug("set success, {}",10);
    promise.setSuccess(10);
});

log.debug("start...");
log.debug("{}",promise.getNow()); // 还没有结果
log.debug("{}",promise.get());

输出

11:51:53 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - start...
11:51:53 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - null
11:51:54 [DEBUG] [defaultEventLoop-1-1] c.i.o.DefaultPromiseTest2 - set success, 10
11:51:54 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - 10
3.3.3.2 异步处理任务成功
DefaultEventLoop eventExecutors = new DefaultEventLoop();
DefaultPromise<Integer> promise = new DefaultPromise<>(eventExecutors);

// 设置回调，异步接收结果
promise.addListener(future -> {
    // 这里的 future 就是上面的 promise
    log.debug("{}",future.getNow());
});

// 等待 1000 后设置成功结果
eventExecutors.execute(()->{
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.debug("set success, {}",10);
    promise.setSuccess(10);
});

log.debug("start...");

输出

11:49:30 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - start...
11:49:31 [DEBUG] [defaultEventLoop-1-1] c.i.o.DefaultPromiseTest2 - set success, 10
11:49:31 [DEBUG] [defaultEventLoop-1-1] c.i.o.DefaultPromiseTest2 - 10
3.3.3.3 同步处理任务失败 - sync & get
DefaultEventLoop eventExecutors = new DefaultEventLoop();
DefaultPromise<Integer> promise = new DefaultPromise<>(eventExecutors);

eventExecutors.execute(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    RuntimeException e = new RuntimeException("error...");
    log.debug("set failure, {}", e.toString());
    promise.setFailure(e);
});

log.debug("start...");
log.debug("{}", promise.getNow());
promise.get(); // sync() 也会出现异常，只是 get 会再用 ExecutionException 包一层异常

输出

12:11:07 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - start...
12:11:07 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - null
12:11:08 [DEBUG] [defaultEventLoop-1-1] c.i.o.DefaultPromiseTest2 - set failure, java.lang.RuntimeException: error...
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.RuntimeException: error...
	at io.netty.util.concurrent.AbstractFuture.get(AbstractFuture.java:41)
	at com.itcast.oio.DefaultPromiseTest2.main(DefaultPromiseTest2.java:34)
Caused by: java.lang.RuntimeException: error...
	at com.itcast.oio.DefaultPromiseTest2.lambda$main$0(DefaultPromiseTest2.java:27)
	at io.netty.channel.DefaultEventLoop.run(DefaultEventLoop.java:54)
	at io.netty.util.concurrent.SingleThreadEventExecutor$5.run(SingleThreadEventExecutor.java:918)
	at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
	at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
	at java.lang.Thread.run(Thread.java:745)
3.3.3.4 同步处理任务失败 - await
DefaultEventLoop eventExecutors = new DefaultEventLoop();
DefaultPromise<Integer> promise = new DefaultPromise<>(eventExecutors);

eventExecutors.execute(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    RuntimeException e = new RuntimeException("error...");
    log.debug("set failure, {}", e.toString());
    promise.setFailure(e);
});

log.debug("start...");
log.debug("{}", promise.getNow());
promise.await(); // 与 sync 和 get 区别在于，不会抛异常
log.debug("result {}", (promise.isSuccess() ? promise.getNow() : promise.cause()).toString());

输出

12:18:53 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - start...
12:18:53 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - null
12:18:54 [DEBUG] [defaultEventLoop-1-1] c.i.o.DefaultPromiseTest2 - set failure, java.lang.RuntimeException: error...
12:18:54 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - result java.lang.RuntimeException: error...
3.3.3.5 异步处理任务失败
DefaultEventLoop eventExecutors = new DefaultEventLoop();
DefaultPromise<Integer> promise = new DefaultPromise<>(eventExecutors);

promise.addListener(future -> {
    log.debug("result {}", (promise.isSuccess() ? promise.getNow() : promise.cause()).toString());
});

eventExecutors.execute(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    RuntimeException e = new RuntimeException("error...");
    log.debug("set failure, {}", e.toString());
    promise.setFailure(e);
});

log.debug("start...");

输出

12:04:57 [DEBUG] [main] c.i.o.DefaultPromiseTest2 - start...
12:04:58 [DEBUG] [defaultEventLoop-1-1] c.i.o.DefaultPromiseTest2 - set failure, java.lang.RuntimeException: error...
12:04:58 [DEBUG] [defaultEventLoop-1-1] c.i.o.DefaultPromiseTest2 - result java.lang.RuntimeException: error...
3.3.3.6 await 死锁检查
DefaultEventLoop eventExecutors = new DefaultEventLoop();
DefaultPromise<Integer> promise = new DefaultPromise<>(eventExecutors);

eventExecutors.submit(()->{
    System.out.println("1");
    try {
		//调用await，导致产生锁
        promise.await();  
        // 注意不能仅捕获 InterruptedException 异常
        // 否则 死锁检查抛出的 BlockingOperationException 会继续向上传播
        // 而提交的任务会被包装为 PromiseTask，它的 run 方法中会 catch 所有异常然后设置为 Promise 的失败结果而不会抛出
    } catch (Exception e) { 
        e.printStackTrace();
    }
    System.out.println("2");
});

输出

17:29:37 [INFO ] [defaultEventLoop-1-1] c.i.n.c.TestNettyPomise - 1
17:29:37 [INFO ] [defaultEventLoop-1-1] c.i.n.c.TestNettyPomise - 2
io.netty.util.concurrent.BlockingOperationException: DefaultPromise@4b16a003(incomplete)
	at io.netty.util.concurrent.DefaultPromise.checkDeadLock(DefaultPromise.java:384)
	at io.netty.util.concurrent.DefaultPromise.await(DefaultPromise.java:212)
	at com.itcxc.netty.c3.TestNettyPomise.lambda$main$0(TestNettyPomise.java:25)
	at io.netty.util.concurrent.PromiseTask$RunnableAdapter.call(PromiseTask.java:38)
	at io.netty.util.concurrent.PromiseTask.run(PromiseTask.java:73)
	at io.netty.channel.DefaultEventLoop.run(DefaultEventLoop.java:54)
	at io.netty.util.concurrent.SingleThreadEventExecutor$5.run(SingleThreadEventExecutor.java:918)
	at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
	at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
	at java.lang.Thread.run(Thread.java:748)
头未秃
关注
专栏目录
jpromise:使用netty实现node.js的Promise的Java实现
05-20
概述 JPromise是node.js的延迟/承诺模式的实现。 根据 Promise是可写的，而Future是只读的。 JAVA将其实现为 。 Netty将其实现为和但是node.js将Promise视为只读对象。 和DeferredObject为可写。 它遵循node.js的概念。 JPromise与非常相似。 主要区别在于它使用netty的promise实现。 它使JPromise能够选择将在其中执行回调的线程。 它仅支持JAVA8。我喜欢lambda表达式。 要求 JAVA 8 净值 玛文 尚不支持。 您必须自己构建工件。 下载资源 使用mvn构建工件 mvn clean;mvn install 例子 基本的 DeferredObject< Integer> deferred = new DeferredObject<> (); Promise promise = d
netty中ChannelFuture.sync()的作用是什么？
gorden5566的专栏
11-26 6280
如果你使用过 netty，你一定见过下面两行代码，它们可以说是创建一个 netty server 的标配代码 1 2 ChannelFuture future = bootstrap.bind(port).sync(); future.channel().closeFuture().sync(); 不知道你有没想过这里面的sync()的作用是什么，如果去掉会有什么问题？ bootstrap.bind(port).sync() 分析 先来一步一步..
Dart基础——Dart异步Future与事件循环Event Loop
JackWu blog
01-14 1614
如何使用异步Future 什么是异步 如果你的程序中有两个方法，这两个方法桉顺序执行，第一个方法执行需要五秒，如果是同步代码，第二个方法会等待第一个方法执行完，才会被调用， 如果第一个方法是异步的，程序在执行第一个方法时，不会等待它执行结束，而是接着执行第二个方法，这样第二个方法就无需在第一个方法执行完之后被调用。 在客户端异步是非常有用的，如果你在初始化时有一个非常耗时，但又不需要它在ui画面响应前执行完成的方法，你就可以使用异步。 Dart异步处理库Future 了解了异步的概念后，我们来看一看如何在D
Flutter异步async操作--Future
wang_hang_的博客
08-25 866
文章参考 王叔不秃 一、获取一个Future import 'package:http/http.dart' as http; void _incrementCounter() { http.get(Uri(host: 'www.baidu.com')); } /// get方法返回的就是一个Future Future<Response> head(Uri url, {Map<String, String>? headers}) => _wit
深入了解Flutter中Future的全部工厂方法及使用
最新发布
爱喝水程序员的博客
03-22 708
在Flutter中，Future是一种表示异步操作结果的对象。它代表了一个可能已经完成或尚未完成的计算，可以用来处理异步任务。Flutter提供了多种工厂方法来创建Future对象，每种方法都有其特定的用途和优势。在本文中，我们将深入探讨Flutter中Future的全部工厂方法，并提供使用示例。
netty-all-4.1.5.Final:netty-all-4.1.5.Final源码学习
03-24
9. **Future和Promise**：Netty中的异步编程模型，Future表示一个待完成的操作，Promise则允许你设置操作的结果或者与另一个Promise进行链接。 10. **WebSocket和HTTP/2支持**：Netty提供了对WebSocket和HTTP/2协议...
Netty实战-leolee-netty-practice.zip
11-07
10. **Future和Promise**: Netty使用Future和Promise来处理异步操作的结果。Future表示一个尚未完成的操作，而Promise则允许我们主动设置操作结果。 这个实践项目可能涵盖了以上这些概念的使用，包括如何创建服务器...
03-04-08-Promise与Future双子星的秘密1
08-04
Promise（承诺）和Future（未来）是Java并发处理的关键组件，它们在Netty中的应用加深了异步操作的灵活性和效率。 Java标准库中的`java.util.concurrent.Future`接口表示一个异步计算的结果。它提供了一个`get`方法...
netty-4.1.4-jar包
11-23
6. **Future** 和 **Promise**：异步编程的关键概念，Future表示某个操作的结果，Promise允许你设置未来完成的操作的结果。 Netty的这些核心组件和设计模式使其成为构建分布式系统、微服务、游戏服务器等高性能网络...
netty-4.1源代码
10-27
2. **Promise** 和 **Future**: 异步编程的重要工具，Promise用于设置结果，Future用于获取结果，两者配合可以实现非阻塞的异步操作。 3. **Zero-Copy**: 利用直接内存和FileRegion进行数据传输，减少系统调用，提高...
为什么阿里巴巴禁止开发人员使用isSuccess作为变量名（修订版）
热门推荐
勇往直前的专栏
12-19 1万+
在日常开发中，我们会经常要在类中定义布尔类型的变量，比如在给外部系统提供一个RPC接口的时候，我们一般会定义一个字段表示本次请求是否成功的。 关于这个”本次请求是否成功”的字段的定义，其实是有很多种讲究和坑的，稍有不慎就会掉入坑里，作者在很久之前就遇到过类似的问题，本文就来围绕这个简单分析一下。到底该如何定一个布尔类型的成员变量。 一般情况下，我们可以有以下四种方式来定义一个布尔类型的成员变量...
netty之future和promise详解
小尘_OnMyWay的博客
04-05 823
文章目录Future和PromiseJDK Futurenetty Futurenetty Promise Future和Promise jdk Future：只能同步等待任务结束才能得到结果 netty Future： 可以同步或者异步等待任务结束之后得到结果，继承自jdk Future。 netty promise：脱离了任务而独立存在，作为两个线程间传递结果的容器，继承自netty Future。 JDK Future 一个例子： package com.throne.netty.test1.futu
Netty编程（四）—— Future与Promise
lizefeng1998的博客
11-23 656
Netty编程（四）—— Future与Promise 文章目录Netty编程（四）—— Future与Promise概念JDK FutureNetty FutureNetty Promise 概念 netty 中的 Future 与 jdk 中的 Future 同名，但是是两个接口，netty 的 Future 继承自 jdk 的 Future，而 Promise 又对 netty Future 进行了扩展（继承） jdk Future 只能同步等待任务结束（或成功、或失败）才能得到结果 netty F
netty学习笔记（二）Promise与Future
qq_41096887的博客
01-19 507
netty学习笔记（二）Promise与Future 先来概述下两者之间与JDK future之间的关系 Netty Future继承了JDK的Future 同时加强了JDk future的一些功能，比如异步处理，同步获取结果 而Promise继承了Netty Future，他可以做到异步的处理，异步的获取结果 Future 先来看一段代码 // 获取线程池 NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
java Future & netty Future & Promise 实际代码演示(如何获取子线程的返回结果)
怀着一颗学徒的心
06-21 435
java Future & netty Future & Promise 的区别(如何获取子线程的返回结果)
Netty源码解读DefaultPromise
10-20 2942
这个类是做什么的这个类是用来获取结果信息的，就是用来获取线程执行的结果信息，但是在获取结果信息的时候，还可以添加一些监听的信息。该类的继承结构该类是netty底层源码最基础的类，其他的类都是依赖该类的实现，结构为 java中的Future->Future>AbstractFuture->DefaultPromise 内部有一个 volatile Object result;对象，用来表示设置该P
探索Netty并发包之Future&Promise
我神级欧文的博客
07-07 1707
探索Netty并发包之Future&Promise
netty sync方法_Netty 源码解析（三）: Netty 的 Future 和 Promise
weixin_39651325的博客
12-21 766
今天是猿灯塔“365篇原创计划”第三篇。接下来的时间灯塔君持续更新Netty系列一共九篇Netty 源码解析(一): 开始Netty 源码解析(二): Netty 的 Channel当前：Netty 源码解析(三): Netty 的 Future 和 PromiseNetty 源码解析(四): Netty 的 ChannelPipelineNetty 源码解析(五): Netty 的线程池分析Ne...
【netty】Netty并发工具-Promise
九师兄
02-12 2115
1.概述 转载并且补充：从源码上理解Netty并发工具-Promise 2.前提 最近一直在看Netty相关的内容，也在编写一个轻量级的RPC框架来练手，途中发现了Netty的源码有很多亮点，某些实现甚至可以用苛刻来形容。另外，Netty提供的工具类也是相当优秀，可以开箱即用。这里分析一下个人比较喜欢的领域，并发方面的一个Netty工具模块 - Promise。 环境版本： Netty:4.1.44.Final JDK1.8 3.Promise简介 Promise，中文翻译为承诺或者许诺，含义是人与.
Netty深入解析：Promise与Future的秘密
"深入学习Netty核心机制，包括Promise与Future的概念及应用，以及Netty的异步处理方式" 在Netty框架中，Promise与Future是实现异步编程的关键概念，它们是Netty对Java标准库中Future接口的扩展和增强。Future在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值