【Netty 专栏】深入浅出 Netty read

netty byteBuf readBytes方法的小坑(内存溢出,LEAK问题) netty LEAK readBytes 阅读详情

点击上方“芋道源码”,选择“置顶公众号”

技术文章第一时间送达!

源码精品专栏

 

摘要: 原创出处 https://www.jianshu.com/p/6b48196b5043 「占小狼」欢迎转载,保留摘要,谢谢!


boss线程主要负责监听并处理accept事件,将socketChannel注册到work线程的selector,由worker线程来监听并处理read事件,本节主要分析Netty如何处理read事件。

img

accept->read

当work线程的selector检测到OP_READ事件发生时,触发read操作。

//NioEventLoop
if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
    unsafe.read();
    if (!ch.isOpen()) {
        // Connection already closed - no need to handle write.
        return;
    }
}

该read方法定义在类NioByteUnsafe中。

//AbstractNioByteChannel.NioByteUnsafe
public final void read() {
    final ChannelConfig config = config();
    if (!config.isAutoRead() && !isReadPending()) {
        // ChannelConfig.setAutoRead(false) was called in the meantime
        removeReadOp();
        return;
    }

    final ChannelPipeline pipeline = pipeline();
    final ByteBufAllocator allocator = config.getAllocator();
    final int maxMessagesPerRead = config.getMaxMessagesPerRead();
    RecvByteBufAllocator.Handle allocHandle = this.allocHandle;
    if (allocHandle == null) {
        this.allocHandle = allocHandle = config.getRecvByteBufAllocator().newHandle();
    }

    ByteBuf byteBuf = null;
    int messages = 0;
    boolean close = false;
    try {
        int totalReadAmount = 0;
        boolean readPendingReset = false;
        do {
            byteBuf = allocHandle.allocate(allocator);
            int writable = byteBuf.writableBytes();
            int localReadAmount = doReadBytes(byteBuf);
            if (localReadAmount <= 0) {
                // not was read release the buffer
                byteBuf.release();
                byteBuf = null;
                close = localReadAmount < 0;
                break;
            }
            if (!readPendingReset) {
                readPendingReset = true;
                setReadPending(false);
            }
            pipeline.fireChannelRead(byteBuf);
            byteBuf = null;

            if (totalReadAmount >= Integer.MAX_VALUE - localReadAmount) {
                // Avoid overflow.
                totalReadAmount = Integer.MAX_VALUE;
                break;
            }

            totalReadAmount += localReadAmount;

            // stop reading
            if (!config.isAutoRead()) {
                break;
            }

            if (localReadAmount < writable) {
                // Read less than what the buffer can hold,
                // which might mean we drained the recv buffer completely.
                break;
            }
        } while (++ messages < maxMessagesPerRead);

        pipeline.fireChannelReadComplete();
        allocHandle.record(totalReadAmount);

        if (close) {
            closeOnRead(pipeline);
            close = false;
        }
    } catch (Throwable t) {
        handleReadException(pipeline, byteBuf, t, close);
    } finally {
        // Check if there is a readPending which was not processed yet.
        // This could be for two reasons:
        // * The user called Channel.read() or ChannelHandlerContext.read() in channelRead(...) method
        // * The user called Channel.read() or ChannelHandlerContext.read() in channelReadComplete(...) method
        //
        // See https://github.com/netty/netty/issues/2254
        if (!config.isAutoRead() && !isReadPending()) {
            removeReadOp();
        }
    }
}

1、allocHandle负责自适应调整当前缓存分配的大小,以防止缓存分配过多或过少,先看看AdaptiveRecvByteBufAllocator内部实现:

public class AdaptiveRecvByteBufAllocator implements RecvByteBufAllocator {
    static final int DEFAULT_MINIMUM = 64;
    static final int DEFAULT_INITIAL = 1024;
    static final int DEFAULT_MAXIMUM = 65536;
    private static final int INDEX_INCREMENT = 4;
    private static final int INDEX_DECREMENT = 1;
    private static final int[] SIZE_TABLE;
}

SIZE_TABLE:按照从小到大的顺序预先存储可以分配的缓存大小。
从16开始,每次累加16,直到496,接着从512开始,每次增大一倍,直到溢出。
DEFAULT_MINIMUM:最小缓存(64),在SIZE_TABLE中对应的下标为3。
**DEFAULT_MAXIMUM **:最大缓存(65536),在SIZE_TABLE中对应的下标为38。
**DEFAULT_INITIAL **:初始化缓存大小,第一次分配缓存时,由于没有上一次实际收到的字节数做参考,需要给一个默认初始值。
INDEX_INCREMENT:上次预估缓存偏小,下次index的递增值。
**INDEX_DECREMENT **:上次预估缓存偏大,下次index的递减值。

2、allocHandle.allocate(allocator) 申请一块指定大小的内存。

//AdaptiveRecvByteBufAllocator.HandleImpl
public ByteBuf allocate(ByteBufAllocator alloc) {
    return alloc.ioBuffer(nextReceiveBufferSize);
}

通过ByteBufAllocator的ioBuffer方法申请缓存。

//AbstractByteBufAllocator
public ByteBuf ioBuffer(int initialCapacity) {
    if (PlatformDependent.hasUnsafe()) {
        return directBuffer(initialCapacity);
    }
    return heapBuffer(initialCapacity);
}

根据平台是否支持unsafe,选择使用直接物理内存还是堆上内存。

direct buffer方案:

//AbstractByteBufAllocator
public ByteBuf directBuffer(int initialCapacity) {
    return directBuffer(initialCapacity, Integer.MAX_VALUE);
}

public ByteBuf directBuffer(int initialCapacity, int maxCapacity) {
    if (initialCapacity == 0 && maxCapacity == 0) {
        return emptyBuf;
    }
    validate(initialCapacity, maxCapacity);
    return newDirectBuffer(initialCapacity, maxCapacity);
}

//UnpooledByteBufAllocator
protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
    ByteBuf buf;
    if (PlatformDependent.hasUnsafe()) {
        buf = new UnpooledUnsafeDirectByteBuf(this, initialCapacity, maxCapacity);
    } else {
        buf = new UnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
    }
    return toLeakAwareBuffer(buf);
}

UnpooledUnsafeDirectByteBuf是如何实现缓存管理的?对Nio的ByteBuffer进行了封装,通过ByteBuffer的allocateDirect方法实现缓存的申请。

protected UnpooledUnsafeDirectByteBuf(ByteBufAllocator alloc, ByteBuffer initialBuffer, int maxCapacity) {
    //判断逻辑已经忽略
   this.alloc = alloc;
   setByteBuffer(allocateDirect(initialCapacity));
}

protected ByteBuffer allocateDirect(int initialCapacity) {
    return ByteBuffer.allocateDirect(initialCapacity);
}

private void setByteBuffer(ByteBuffer buffer) {
    ByteBuffer oldBuffer = this.buffer;
    if (oldBuffer != null) {
        if (doNotFree) {
            doNotFree = false;
        } else {
            freeDirect(oldBuffer);
        }
    }
    this.buffer = buffer;
    memoryAddress = PlatformDependent.directBufferAddress(buffer);
    tmpNioBuf = null;
    capacity = buffer.remaining();
}

memoryAddress = PlatformDependent.directBufferAddress(buffer) 获取buffer的address字段值,指向缓存地址。
capacity = buffer.remaining() 获取缓存容量。

方法toLeakAwareBuffer(buf)对申请的buf又进行了一次包装:

protected static ByteBuf toLeakAwareBuffer(ByteBuf buf) {
    ResourceLeak leak;
    switch (ResourceLeakDetector.getLevel()) {
        case SIMPLE:
            leak = AbstractByteBuf.leakDetector.open(buf);
            if (leak != null) {
                buf = new SimpleLeakAwareByteBuf(buf, leak);
            }
            break;
        case ADVANCED:
        case PARANOID:
            leak = AbstractByteBuf.leakDetector.open(buf);
            if (leak != null) {
                buf = new AdvancedLeakAwareByteBuf(buf, leak);
            }
            break;
    }
    return buf;
}

Netty中使用引用计数机制来管理资源,ByteBuf实现了ReferenceCounted接口,当实例化一个ByteBuf时,引用计数为1, 代码中需要保持一个该对象的引用时需要调用retain方法将计数增1,对象使用完时调用release将计数减1。当引用计数变为0时,对象将释放所持有的底层资源或将资源返回资源池。

3、方法doReadBytes(byteBuf) 将socketChannel数据写入缓存。

//NioSocketChannel
@Override
protected int doReadBytes(ByteBuf byteBuf) throws Exception {
    return byteBuf.writeBytes(javaChannel(), byteBuf.writableBytes());
}

//WrappedByteBuf
@Override
public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
    return buf.writeBytes(in, length);
}

//AbsractByteBuf
@Override
public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
    ensureAccessible();
    ensureWritable(length);
    int writtenBytes = setBytes(writerIndex, in, length);
    if (writtenBytes > 0) {
        writerIndex += writtenBytes;
    }
    return writtenBytes;
}

//UnpooledUnsafeDirectByteBuf
@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ensureAccessible();
    ByteBuffer tmpBuf = internalNioBuffer();
    tmpBuf.clear().position(index).limit(index + length);
    try {
        return in.read(tmpBuf);
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}

private ByteBuffer internalNioBuffer() {
    ByteBuffer tmpNioBuf = this.tmpNioBuf;
    if (tmpNioBuf == null) {
        this.tmpNioBuf = tmpNioBuf = buffer.duplicate();
    }
    return tmpNioBuf;
}

最终底层采用ByteBuffer实现read操作,这里有一块逻辑不清楚,为什么要用tmpNioBuf?

int localReadAmount = doReadBytes(byteBuf);
1、如果返回0,则表示没有读取到数据,则退出循环。
2、如果返回-1,表示对端已经关闭连接,则退出循环。
3、否则,表示读取到了数据,数据读入缓存后,触发pipeline的ChannelRead事件,byteBuf作为参数进行后续处理,这时自定义Inbound类型的handler就可以进行业务处理了。

static class DiscardServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        try {
            while (in.isReadable()) { // (1)
                System.out.print((char) in.readByte());
                System.out.flush();
            }
        } finally {
            ReferenceCountUtil.release(msg); // (2)
        }
    }
}

其中参数msg,就是对应的byteBuf,当请求的数据量比较大时,会多次触发channelRead事件,默认最多触发16次,可以通过maxMessagesPerRead字段进行配置。
如果客户端传输的数据过大,可能会分成好几次传输,因为TCP一次传输内容大小有上限,所以同一个selectKey会触发多次read事件,剩余的数据会在下一轮select操作继续读取。

在实际应用中,应该把所有请求数据都缓存起来再进行业务处理。
所有数据都处理完,触发pipeline的ChannelReadComplete事件,并且allocHandle记录这次read的字节数,进行下次处理时缓存大小的调整。

到此为止,整个NioSocketChannel的read事件已经处理完成。

666. 彩蛋

如果你对 Netty 并发感兴趣,欢迎加入我的知识星球一起交流。


知识星球

目前在知识星球(https://t.zsxq.com/2VbiaEu)更新了如下 Dubbo 源码解析如下:

01. 调试环境搭建
02. 项目结构一览
03. API 配置(一)之应用
04. API 配置(二)之服务提供者
05. API 配置(三)之服务消费者
06. 属性配置
07. XML 配置
08. 核心流程一览

09. 拓展机制 SPI

10. 线程池

11. 服务暴露(一)之远程暴露(Injvm)

12. 服务暴露(二)之远程暴露(Dubbo)

...
一共 60 篇++

ABAP_自定义屏幕07—下拉列表框 ABAP_自定义屏幕07—下拉列表框 完成以下:页面中有下拉列表框,下拉框value=系统表SCRR的值 1、实现方法A-常用 1.1 在主程序定义字段 TYPES:BEGIN OF type_carrid, carrid LIKE scarr-carrid,"航线代码 carrname LIKE scarr-carrname,"航向名称 END OF type_carrid. DATA g_it_carrid TYPE STANDARD TABLE OF type_carrid 阅读详情

相关推荐

Pixhawk RPi CM4 Baseboard 树莓派CM4安装Ubuntu20.04 server 配置ros mavros mavsdk

cm4配置ros mavros连接pixhawk4 Pixhawk RPi CM4 Baseboard

baidu_41704597的博客 2129

Netty:ByteBuf写入数据、读出数据

Netty:ByteBuf写入数据、读出数据

听海边涛声 7825

IAP板卡远程升级(串口网口都可)+Ymodem+AES对bin文件加密+pc软件+板卡相互烧录

还是决定记录一下,毕竟这个东西我也搞了挺久的,遇到一些棘手的,或者是因为我很粗心遇到的问题也和大家分享一下,。 板卡核心是 STM32F103RCT6,256kflash 前言 开始看这个远程升级的时候,我是一头雾水的,原子哥的教程里面也有说到过iap,有了一个大概的了解,我想不明白的是,通过串口下载的方式把hex文件下载到flash,和把bin文件下载到flash难道不是拉一根线,下载一个文件嘛,(初入职场的我并没有考虑到安全这个问题)如果直接将hex文件给到客户那边,风险是非常大...

那可真是太开心了的博客 5371

Netty in action—Netty中的ByteBuf

正如之前所说,网络传输的基本单位是字节。Java NIO 提供了ByteBuffer作为它的容器,但是这个类使用起来比较复杂和麻烦。Netty提供了一个更好的实现:ByteBuf。ByteBuf的APINetty为数据处理提供的API通过抽象类ByteBuf和接口ByteBufHolder暴露出来。 下面列出ByteBuf API的优点: 可扩展到用户定义的buffer类型中 通过内置的复合buf

日积月累,天道酬勤 1万+

解决RuntimeError: Couldn‘t load custom C++ ops. This can happen if your PyTorch

刚下好yolov8的代码,想测一下能否成果,果然没成功,报错如下简单来说就是torchvision和torch不匹配,就很离谱,我照着版本对应关系pip install的啊,怎么会不匹配建议先看看你的版本我是下图红框这个首先确定自己torch没问题,因为我的3090这个卡目前cuda版本是11.1,这个whl是早就下好的,一般1-2G,有问题重新下就麻烦了然后我pip install了很多次torchvision==0.11.3,都没啥用。想试着改改版本,结果要下其他的torch版本,就更不可能了。

DZY的博客 2248

自然二进制数与格雷码的相互转换

自然二进制数与格雷码两者优势: 自然二进制数的编码方式简单明了,容易理解,在加减运算中能够直接进行,同时十分方便进行一些位运算操作(如移位、取反等)。 格雷码计数时只有一位变化,可有效减少计数器状态的冗余转换,同时在传输数据时能够减小传输错误的概率,此外带权重编码处理更加方便。 在一定程度上自然二进制数与格雷码优缺点基本相反,综上所述,自然二进制数和格雷码各有优劣之处,需要根据具体应用场景选择合适的编码方式。简单来说,在计数器和编码器中,倾向于使用格雷码;而在进行加减运算时,则倾向于使用自然二进制数。

Loudrs的博客 7495

Netty-bytebuf

Netty提供了ByteBuf来替代Java NIO的ByteBuffer缓冲区,以操纵内存缓冲区。ByteBuf的优势ByteBuf的逻辑部分ByteBuf是一个字节容器,内部是一个字节数组。从逻辑上来分,字节容器内部可以分为四个部分,具体如图6-14所示。 第一个部分是已用字节,表示已经使用完的废弃的无效字节;第二部分是可读字节,这部分数据是ByteBuf保存的有效数据,从ByteBuf中读取的数据都来自这一部分;第三部分是可写字节,写入到ByteBuf的数据都会写到这一部分中;第四部分是可扩容字节,表

yitian881112的专栏 1205

手把手教你用ComfyUI搭建高效AI绘画工作流:从基础到高级技巧

本文详细介绍了如何使用ComfyUI构建高效的AI绘画工作流,从基础配置到高级技巧全面覆盖。通过模块化设计,ComfyUI显著提升显存利用率和创作灵活性,适合从新手到专业用户。文章包含部署指南、工作流搭建、性能优化及行业应用案例,帮助读者快速掌握AI绘画核心技术。

7up55的博客 720

Netty ByteBuf 按位读操作

前言 最近与一个刚接触Netty的学生关于Netty读字节流方面的操作进行讲解,可能对后来同学有点点帮助,所以整理出来供大家探讨。 ByteBuf读操作 ByteBuf读操作我们常用的有一下几种: ByteBuf.readByte() 读一个字节,有符号 ByteBuf.readUnsignedByte() 读一个字节,无符号 ByteBuf.readShort()读连续的两个字节,有符号 ByteBuf....

谁念西风独自凉 6312

香橙派5上跑DeepSeek-R1的避坑指南:从模型下载到NPU加速全流程解析

本文详细解析了在香橙派5(RK3588)上部署DeepSeek-R1蒸馏模型的完整流程与优化技巧。内容涵盖从系统配置、RKLLM工具链编译、模型转换到NPU加速调优的全过程,重点分享了如何利用RK3588的NPU算力实现高效推理,并提供了常见问题的解决方案,为边缘设备部署LLM提供了实用指南。

CAT789的专栏 717

量化回测框架三选一:Backtrader、Zipline、PyAlgoTrade,新手到底该跟谁学?

本文对比分析了三大量化回测框架Backtrader、Zipline和PyAlgoTrade,帮助新手选择最适合的入门工具。从安装配置、策略编写到文档查阅,详细解析各框架的特点和适用场景,为量化交易初学者提供实用指南。

weixin_28745309的博客 268

Netty的ByteBuf和消息处理

当 Channel 接收到数据时,数据将会被传递给 ChannelPipeline 的第一个 ChannelHandler,然后经过一系列的处理之后,最终被传递给 ChannelPipeline 的最后一个 ChannelHandler。在 decode 方法中,我们读取 ByteBuf 中的数据,并将其解码为 Message 对象,然后将其添加到 out 列表中。ByteBuf 支持多种访问模式和多种类型的数据,同时也提供了一些便利的方法来访问数据,例如支持动态扩容,支持链式调用等。

lonely_baby的博客 1149

AutoSAR系列讲解 - 前言

博主xyfx是一名汽车行业的嵌入式软件工程师,本职工作是同步电机的驱动控制(主要做FOC的,这个大家要是有兴趣,以后可以单独开一个专栏来讲解一下),由于做控制器的时候需要用到AutoSAR,所以特意的去学习了相关知识,同时博主自己也在同步提高中,有写的不合理的地方也请大家指正。我准备对AutoSAR开设两个大的方面来讲解,一是AutoSAR的入门篇,二是AutoSAR的实践篇,分别讲述AutoSAR的理论基础和工具的使用。

雪云飞星的博客 4万+

netty系列之:netty中的核心编码器bytes数组

文章目录简介byte是什么netty中的byte数组的工具类netty中byte的编码器总结 简介 我们知道netty中数据传输的核心是ByteBuf,ByteBuf提供了多种数据读写的方法,包括基本类型和byte数组的读写方法。如果要在netty中传输这些数据,那么需要构建ByteBuf,然后调用ByteBuf中对应的方法写入对应的数据,接着套用netty中标准的模板即可使用。 对于byte数组来说,如果每次都将其封装进ByteBuf中,再进行传输显得有些麻烦。于是netty提供了一个基于bytes的核心

程序那些事 2492

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Netty学习之ByteBuf

Netty学习之ByteBuf 前言 在网络中传输的基本单元是字节byte,虽然在NIO中提供了一个ByteBuffer作为字节的容器,不过由于ByteBuffer比较难使用,所以Netty自己实现了一个,ByteBuf,并且提供了比较灵活的操作方式以及操作工具,本节我们将详细学习这一部分的知识。 ByteBuf 在Netty中,数据通过ByteBuf以及ByteBufHolder来进行操作,By...

曾经沧海难为水,除却巫山不是云 962

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Netty 中的读和写

ChannelInboundHandler 使用了责任链模式,每个 ChannelInboundHandler 就相当于一个拦截器,对它感兴趣的数据进行处理,比如编解码,解析http,websocket协议等,ChannelOutboundHandler 对数据进行写操作,它底层是一个Entry 链表。1,在简单的手写Netty demo项目中,Netty 读和写数据都是对 Channel 的读和写,也就是对NioSocketChannel 中的 SelectableChannel 的读和写。

qq_38148090的博客 647

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Netty简介及ByteBuf组件原理

Netty简介及ByteBuf组件原理

datacreating的博客 302

netty 使用记录

实现NIO就是非阻塞的,事件驱动:连接成功、端口连接、接收到消息都是一个事件,沾包拆包:这是个啥听不懂,tcp连接成功后消息就一直往服务器(客户端)发这里就有一个情况。我这里的需求是每个发送的命令处理的代码会不一样,每个地方都写一套新的netty代码又不符合我们的一套协议的设计,使用这种方式的前提是请求参数里面可以携带唯一ID。我这里接入的是国外的一家厂商HelvarNet协议,基本上就是想使用netty的nio避免线程阻塞,使用了就少不了沾包拆包。命令规范是这种的 ,有头有尾,就是根据这个拆的包。

lanyanhua的博客 175

Netty进阶:浅析Read事件的处理过程

文章目录1.read2. ByteBufAllocator3.Handle4. allocate5. 读取到ByteBuf总结 上篇文章讲述了Accept事件的处理过程,本文将详细分析Read过程中的细节。按照accept事件的思路,当读事件进来的时候,会调用 unsafe 的 read 方法,这个方法的主要作用是读取 Socket 缓冲区的内存,并包装成 Netty 的 ByteBuf 对象,最...

TheLudlows的博客 3713

网络编程-Netty

网络编程-NETTY 【基础篇】 1、TCP、UDP的区别? TCP面向连接(如打电话要先拨号建立连接);UDP是无连接的,即发送数据之前不需要建立连接 TCP提供可靠的服务,UDP尽最大努力交付,即不保证可靠交付 UDP具有较好的实时性,工作效率比TCP高,适用于对高速传输和实时性有较高的通信或广播通信。 .每一条TCP连接只能是点到点的;UDP支持一对一、一对多、多对一和多对多的交...

a578413629的博客 390

Netty——网络编程 NIO(Selector处理read事件 客户端断开问题解决)代码示例

Netty——网络编程 NIO(Selector处理read事件 客户端断开问题解决)代码示例

小志的博客 1762

深入浅出 Netty Read(六):从内核到业务的万字详解

Netty作为高性能异步网络框架,其"读"操作机制是其性能核心。本文深入解析了Netty读取流程的三个关键阶段:首先由事件循环(NioEventLoop)检测到可读事件,触发NioByteUnsafe.read()方法;然后通过智能内存分配(ByteBufAllocator)实现高效数据搬运,采用零拷贝技术将数据从内核缓冲区读取到Netty的ByteBuf;最后数据经由Pipeline责任链传递,经过解码器处理后转换为业务对象。整个过程融合了Reactor线程模型、高效内存管理和事件驱动

油墨香^-^的博客 183

【Netty专题】Netty 中channelRead 和 channelRead0 有什么区别?

最近做项目发现Netty中的channel有channelRead 方法也有channelRead0 方法, 然后思考下这两个有什么区别呢? 我们来直接看源码 channelRead @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { boolean release = true; try { if (acce.

Coinker的博客 1万+

netty中的channelRead()与channelRead0()区别

而writeAndFlush()源码中的write()方法是异步执行的,若其正在处理 msg,而此时 SimpleChannelInboundHandler 中的 channelRead()方法执行完毕了,则会将 msg 给释放了。:在netty的api使用中,一般我们自定义处理器类的时候,会继承ChannelInboundHandlerAdapter或者SimpleChannelInboundHandler。而我们在重写channelRead0()方法的时候,有时场景需要处理接收的信息并发回给对端。

weixin_42037190的博客 4642

netty源码浅析-客户端接入

客户端接入 当客户端调用connect后,服务端reactor线程在循环过程中会检查到这个事件,然后在processSelectedKey方法中处理。我们在上面也已经提到了这个方法,我们继续跟进,当客户端接入后,服务端发生了什么。 //读事件和连接事件就绪,执行unsafe.read() //如果是boss线程则是OP_ACCEPT事件,如果是work线程则是OP_READ事件 if ((readyOps & (SelectionKey.OP_READ | Selection

GeekerJava的博客 338
上一篇: 分布式消息队列 RocketMQ 源码分析 —— Message 拉取与消费(下)
下一篇: 分布式消息队列 RocketMQ 源码分析 —— Message 顺序发送与消费
公众号-芋道源码
博客等级 码龄10年 1637粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值