Netty 源码分析系列（十七）Promise详解

已于 2023-05-30 12:40:23 修改
阅读量2.2k 收藏 3
点赞数
分类专栏： netty 文章标签： java netty 后端
于 2022-03-31 16:18:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiang_wang01/article/details/123876082
版权

系列文章目录

文章目录

前言

上篇文章我们讲解了 Netty 的 Future，本篇文章我就就来分析一下可写的 Future，也就是 promise，Netty 中的 Promise 扩展自 Netty 的 Future。

Promise 接口

在 Netty 中，Promise 接口是一种特殊的可写的 Future。 Promise 的核心源码如下：

public interface Promise<V> extends Future<V> {
    Promise<V> setSuccess(V var1);

    boolean trySuccess(V var1);

    Promise<V> setFailure(Throwable var1);

    boolean tryFailure(Throwable var1);

    boolean setUncancellable();

    Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> var1);

    Promise<V> addListeners(GenericFutureListener<? extends Future<? super V>>... var1);

    Promise<V> removeListener(GenericFutureListener<? extends Future<? super V>> var1);

    Promise<V> removeListeners(GenericFutureListener<? extends Future<? super V>>... var1);

    Promise<V> await() throws InterruptedException;

    Promise<V> awaitUninterruptibly();

    Promise<V> sync() throws InterruptedException;

    Promise<V> syncUninterruptibly();
}

从上面可以看出，Promise 就是一个可写的 Future。在 Future 机制中，业务逻辑所在任务执行的状态（成功或失败）是在 Future 中实现的；而在 Promise 中，可以在业务逻辑中控制任务的执行结果，相比 Future 更加灵活。

以下是一个 Promise 的示例（伪代码）。

//异步的耗时任务接收一个 Promise
public Promise asynchronousFunction() {

    Promise promise = new PromiseImpl();

    Object result = null;

    return =search()  //业务逻辑

        if (sucess) {
            promise.setSuccess(result); //通知 promise 当前异步任务成功了，并传入结果
        } else if (failed) {
            promise.setFailure(reason);//通知 promise 当前异步任务失败了
        } else if (error) {
            promise.setFailure(error);//通知 promise 当前异步任务发生了异常
        }
}

//调用异步的耗时操作
Promise promise = asynchronousFunction(promise);//会立即返回 promise

//添加成功处理 / 失败处理 / 异步处理等事件
promise.addListener();//例如：可以添加成功后的执行事件

//继续做其他事件，不需要理会 asynchronousFunction 何时结束
doOtherThings();

在 Netty 中，Promise 继承了 Future，因此也具备了 Future 的所有功能。在 Promise 机制中，可以在业务逻辑中人工设置业务逻辑的成功与失败。

Netty 的常用 Promise 类有 DefaultPromise 类，这是 Promise 实现的基础，DefaultChannelPromise 是 DefaultPromise 的子类，加入了channel属性。

Netty 的 DefaultPromise

Netty 中涉及异步操作的地方都使用了 Promise 。例如，下面是服务器/客户端启动时的注册任务，最终会调用 Unsafe 的 register，调用过程中会传入一个Promise 。Unsafe 进行事件的注册时调用 Promise 可以设置成功或者失败。

//SingleThreadEventLoop.java
public ChannelFuture register(ChannelPromise promise) {
    ObjectUtil.checkNotNull(promise, "promise");
    promise.channel().unsafe().register(this, promise);
    return promise;
}

//AbstractChannel.AbstractUnsafe
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    ObjectUtil.checkNotNull(eventLoop, "eventLoop");
    if (AbstractChannel.this.isRegistered()) {
        promise.setFailure(new IllegalStateException("registered to an event loop already"));
    } else if (!AbstractChannel.this.isCompatible(eventLoop)) {
        promise.setFailure(new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
    } else {
        AbstractChannel.this.eventLoop = eventLoop;
        if (eventLoop.inEventLoop()) {
            this.register0(promise);
        } else {
            try {
                eventLoop.execute(new Runnable() {
                    public void run() {
                        AbstractUnsafe.this.register0(promise);
                    }
                });
            } catch (Throwable var4) {
                AbstractChannel.logger.warn("Force-closing a channel whose registration task was not accepted by an event loop: {}", AbstractChannel.this, var4);
                this.closeForcibly();
                AbstractChannel.this.closeFuture.setClosed();
                this.safeSetFailure(promise, var4);
            }
        }

    }
}

DefaultPromise 提供的功能可以分为两个部分；一个是为调用者提供 get()和addListen()用于获取 Future 任务执行结果和添加监听事件；另一部分是为业务处理任务提供setSucess()等方法设置任务的成功或失败。

1、设置任务的成功或失败

DefaultPromise 核心源码如下：

public class DefaultPromise<V> extends AbstractFuture<V> implements Promise<V> {

    public Promise<V> setSuccess(V result) {
        if (this.setSuccess0(result)) {
            return this;
        } else {
            throw new IllegalStateException("complete already: " + this);
        }
    }

    public boolean trySuccess(V result) {
        return this.setSuccess0(result);
    }

    public Promise<V> setFailure(Throwable cause) {
        if (this.setFailure0(cause)) {
            return this;
        } else {
            throw new IllegalStateException("complete already: " + this, cause);
        }
    }

    public boolean tryFailure(Throwable cause) {
        return this.setFailure0(cause);
    }

    public boolean setUncancellable() {
        if (RESULT_UPDATER.compareAndSet(this, (Object)null, UNCANCELLABLE)) {
            return true;
        } else {
            Object result = this.result;
            return !isDone0(result) || !isCancelled0(result);
        }
    }

    public boolean isSuccess() {
        Object result = this.result;
        return result != null && result != UNCANCELLABLE && !(result instanceof DefaultPromise.CauseHolder);
    }

    public boolean isCancellable() {
        return this.result == null;
    }

    //...

}

2、获取 Future 任务执行结果和添加监听事件

DefaultPromise 的get方法有 3 个。

  • 无参数的get会阻塞等待；
  • 有参数的get会等待指定事件，若未结束就抛出超时异常，这两个get是在其父类 AbstractFuture中实现的。getNow()方法则会立马返回结果。

源码如下：

public V getNow() {
    Object result = this.result;
    return !(result instanceof DefaultPromise.CauseHolder) && result != SUCCESS && result != UNCANCELLABLE ? result : null;
}

public V get() throws InterruptedException, ExecutionException {
    Object result = this.result;
    if (!isDone0(result)) {
        this.await();
        result = this.result;
    }

    if (result != SUCCESS && result != UNCANCELLABLE) {
        Throwable cause = this.cause0(result);
        if (cause == null) {
            return result;
        } else if (cause instanceof CancellationException) {
            throw (CancellationException)cause;
        } else {
            throw new ExecutionException(cause);
        }
    } else {
        return null;
    }
}

public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
    Object result = this.result;
    if (!isDone0(result)) {
        if (!this.await(timeout, unit)) {
            throw new TimeoutException();
        }

        result = this.result;
    }

    if (result != SUCCESS && result != UNCANCELLABLE) {
        Throwable cause = this.cause0(result);
        if (cause == null) {
            return result;
        } else if (cause instanceof CancellationException) {
            throw (CancellationException)cause;
        } else {
            throw new ExecutionException(cause);
        }
    } else {
        return null;
    }
}

await() 方法判断 Future 任务是否结束，之后获取 this 锁，如果任务未完成则调用 Object 的 wait()等待。源码如下：

public Promise<V> await() throws InterruptedException { 
    if (this.isDone()) {
        return this;
    } else if (Thread.interrupted()) {
        throw new InterruptedException(this.toString());
    } else {
        this.checkDeadLock();
        synchronized(this) {
            while(!this.isDone()) {
                this.incWaiters();

                try {
                    this.wait();
                } finally {
                    this.decWaiters();
                }
            }

            return this;
        }
    }
    
    //...
}

addListener 方法被调用时，将传入的回调传入listeners对象中。如果监听多于 1 个，会创建DeflaultFutureListeners对象将回调方法保存在一个数组中。

removeListener会将listeners设置为null(只有一个时)或从数组中移除（多个回调时）。源码如下。

public Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> listener) {
    ObjectUtil.checkNotNull(listener, "listener");
    synchronized(this) {
        this.addListener0(listener);
    }

    if (this.isDone()) {
        this.notifyListeners();
    }

    return this;
}   

public Promise<V> addListeners(GenericFutureListener<? extends Future<? super V>>... listeners) {
    ObjectUtil.checkNotNull(listeners, "listeners");
    synchronized(this) {
        GenericFutureListener[] var3 = listeners;
        int var4 = listeners.length;
        int var5 = 0;

        while(var5 < var4) {
            GenericFutureListener<? extends Future<? super V>> listener = var3[var5];
            if (listener != null) {
                this.addListener0(listener);
                ++var5;
                continue;
            }
        }
    }

    if (this.isDone()) {
        this.notifyListeners();
    }

    return this;
}

public Promise<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener) {
    ObjectUtil.checkNotNull(listener, "listener");
    synchronized(this) {
        this.removeListener0(listener);
        return this;
    }
}

public Promise<V> removeListeners(GenericFutureListener<? extends Future<? super V>>... listeners) {
    ObjectUtil.checkNotNull(listeners, "listeners");
    synchronized(this) {
        GenericFutureListener[] var3 = listeners;
        int var4 = listeners.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            GenericFutureListener<? extends Future<? super V>> listener = var3[var5];
            if (listener == null) {
                break;
            }

            this.removeListener0(listener);
        }

        return this;
    }
}

在添加监听器的过程中，如果任务刚好执行完毕 done()，则立即触发监听事件。触发监听通过notifyListeners()实现。主要逻辑如下：

如果当前addListener的线程（准确来说应该是调用了notifyListeners的线程，因为addListener和setSuccess都会调用notifyListeners和 Promise 内的线程池）与当前执行的线程是同一个线程，则放在线程池中执行，否则提交到线程池中执行；

而如果是执行 Future 任务的线程池中的setSuccess时，调用notifyListeners()，会放在当前线程中执行。内部维护了notifyListeners用来记录是否已经触发过监听事件，只有未触发过且监听列表不为空，才会依次遍历并调用operationComplete。

Netty 的 DefaultChannelPromise

DefaultChannelPromise 是 DefaultPromise 的子类，内部维护了一个通道变量 channel。

Promise 机制相关的方法都是调用父类方法。

除此之外，DefaultChannelPromise 还实现了FlushCheckpoint接口，供ChannelFlushPromiseNotifier使用，可以将ChannelFuture注册到ChannelFlushPromiseNotifier类，当有数据写入或到达checkpoint时使用。

核心源码如下：

public class DefaultChannelPromise extends DefaultPromise<Void> implements ChannelPromise, FlushCheckpoint {
    private final Channel channel;
    private long checkpoint;

	//...

    public Channel channel() {
        return this.channel;
    }

    public ChannelPromise setSuccess() {
        return this.setSuccess((Void)null);
    }

    public ChannelPromise setSuccess(Void result) {
        super.setSuccess(result);
        return this;
    }

    public boolean trySuccess() {
        return this.trySuccess((Object)null);
    }

    public ChannelPromise setFailure(Throwable cause) {
        super.setFailure(cause);
        return this;
    }

    //...

    public ChannelPromise promise() {
        return this;
    }

    protected void checkDeadLock() {
        if (this.channel().isRegistered()) {
            super.checkDeadLock();
        }

    }

    public ChannelPromise unvoid() {
        return this;
    }

    public boolean isVoid() {
        return false;
    }
}

总结

以上我们分析了 Netty 中的 Promise，知道了它是扩展自 Netty 的 Future，是一个可写的 Future。

初念初恋
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【netty】Netty并发工具-Promise
九师兄
02-12 1861
1.概述 转载并且补充：从源码上理解Netty并发工具-Promise 2.前提 最近一直在看Netty相关的内容，也在编写一个轻量级的RPC框架来练手，途中发现了Netty的源码有很多亮点，某些实现甚至可以用苛刻来形容。另外，Netty提供的工具类也是相当优秀，可以开箱即用。这里分析一下个人比较喜欢的领域，并发方面的一个Netty工具模块 - Promise。 环境版本： Netty:4.1.44.Final JDK1.8 3.Promise简介 Promise，中文翻译为承诺或者许诺，含义是人与.
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之Future与Promise
weixin_38598961的博客
04-17 117
netty之Future与Promise
Netty之Channel（五）disconnect操作
weixin_43257196 的博客
03-17 2362
java原生NIO SocketChannel不存在，调用Netty NioSocketChannel的disconnect(ChannelPromise promise) 时，会自动转换成close操作。 所以嘞，Channel中disconnect(ChannelPromise promise) 方法，是 Netty 为 UDP 设计的。 通过 NioSocketChannel中disconn...
Netty-原理篇(Future&Promise)
S1124654的博客
06-28 869
Future&Promise
探索Netty并发包之Future&Promise
我神级欧文的博客
07-07 1338
探索Netty并发包之Future&Promise
Netty4之Future/Promise异步模型
热门推荐
kobejayandy的专栏
08-19 2万+
java.util.concurrent.Future是Java提供的接口，表示异步执行的状态，Future的get方法会判断任务是否执行完成，如果完成就返回结果，否则阻塞线程，直到任务完成。 [java] view plaincopy // Java FutureTask.get()    public V get() throws InterruptedExceptio
Netty-promise
weixin_30819085的博客
10-30 723
public class TimeEncoder extends ChannelOutboundHandlerAdapter { @Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { ...
探索Netty的Future&Promise
HGW的博客
09-05 346
在异步处理时，经常用到这两个接口首先要说明 netty 中的 Future 与 jdk 中的 Future 同名，但是两个接口，netty 的 Future 继承自 jdk 的 Future，而 Promise 又对 netty Future 进行了扩展。
netty-future和promise的演示以及速率控制的案例
shuixiou1的博客
03-20 2641
netty-future和promise的演示以及速率控制的案例 一、future和promise的演示 1、Future Future 模式 是处理异步执行时的一个处理模式，它有二种编程模式。 第一种：将来式- 让执行线程，可以拿到异步调用的一个标记对象，如果执行线程调用future.get(),那么就能够等待异步执行的结果。 第二种：回调式- 通过给Future添加回调的方式，通过回调拿到异步执行的结果 案例1： /** * 案例1：使用JDk的Future模式 -- 将来式 *.
netty源码分析教程视频
01-28
一个netty的入门教程以及源码分析视频,适合刚学习的人
Netty源码解析.pdf
09-29
netty源码解析PDF,网络编程
netty源码深入分析
12-06
美团基础架构部闪电侠老师的netty源码分析视频
Netty4.x源码分析详解
06-08
Netty4.x源码分析详解
Netty源码分析总结.rar
09-23
Netty源码分析总结.rar
链表刷题集
yajunjiao的专栏
04-30 866
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1391
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
《设计一款蓝牙热敏打印机》
最新发布
唐顺才的博客
05-06 123
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1197
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
netty 源码分析
10-12
＊＊＊于 NIO 的客户端/服务端框架，广泛应用于高性能网络应用程序的开发中。netty 的源码非常庞大，其中涉及到了大量的设计模式和网络协议的实现。对于想要深入了解 netty 的开发者来说，必须要对 netty 的源码进行深入分析和研究。 netty 源码分析的主要内容包括：netty 的整体架构、核心组件的实现、网络协议的支持、线程模型的设计等方面。在分析 netty 源码时，需要对 Java NIO、JDK 并发包、TCP/IP 协议等方面有一定的了解和掌握。同时也需要使用一些工具来辅助分析，比如 IDE、调试器、抓包工具等。 在分析 netty 的源码时，可以从以下几个方面入手： 1. Netty 的整体架构：Netty 的整体架构包括哪些组件，它们之间是如何协作的，这些组件分别在哪些类中实现等等。 2. 核心组件的实现：Netty 的核心组件包括 Channel、EventLoop、Handler 等，这些组件在 Netty 中是如何实现的，它们之间的关系是如何的。 3. 网络协议的支持：Netty 支持哪些网络协议，这些协议在 Netty 中是如何实现的，比如 TCP、UDP、HTTP、WebSocket 等协议。 4. 线程模型的设计：Netty 的线程模型是如何设计的，为什么要采用这种模型，这种模型的优劣势是什么。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值