• 欢迎访问 winrains 的个人网站!
  • 本网站主要从互联网整理和收集了与Java、网络安全、Linux等技术相关的文章,供学习和研究使用。如有侵权,请留言告知,谢谢!

Netty源码分析(6):读写流程

Netty winrains 来源:史圣杰 12个月前 (11-09) 52次浏览

在服务器启动过程初,我们向ServerBootstrap类传入了两个线程池,一个负责处理I/O连接请求,另一个用来处理连接后的读写操作。主事件循环主要负责接收客户端连接,之后创建与客户端连接的NioSocketChannel,然后将其注册到子事件循环上面,由子事件循环负责处理子Channel的读写操作。

6.1 Accept流程

6.1.1 Accept事件的注册

向java的channel注册Accept事件发生在bind阶段(AbstractBootstrap的doBind0方法)结束的最后,bind结束后触发了Pipeline的fireChannelActive事件,经由NioServerSocketChannel的Pipeline的TailContext传播到HeadContext,最后由unsafe向线程池提交fireChannelActive任务完成Accept的注册。

// AbstractChannel.java中的AbstractUnsafe的bind()
if (!wasActive && isActive()) {
    invokeLater(new Runnable() {
        @Override
        public void run() {
            pipeline.fireChannelActive();
        }
    });
}

Pipeline执行fireChannelActive从HeadContext开始触发,Head执行readIfIsAutoRead方法

// DefaultChannelPipeline.java的HeadContext中
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    ctx.fireChannelActive();
    readIfIsAutoRead();
}

在readIfIsAutoRead中,调用channel的read(),由于read是outbound方法,最终会调用NioServerSocketChannel的unsafe的beginRead,在里面注册Accept事件。

// NioServerSocketChannel在创建时,指定了readInterestOp
public NioServerSocketChannel(ServerSocketChannel channel) {
        super(null, channel, SelectionKey.OP_ACCEPT);
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}
// AbstractNioChannel.java中的AbstractNioUnsafe类
protected void doBeginRead() throws Exception {
    // Channel.read() or ChannelHandlerContext.read() was called
    final SelectionKey selectionKey = this.selectionKey;
    if (!selectionKey.isValid()) {
        return;
    }
    readPending = true;
    final int interestOps = selectionKey.interestOps();
    if ((interestOps & readInterestOp) == 0) { // 如果没有设置
        selectionKey.interestOps(interestOps | readInterestOp);
    }
}

6.1.2 Accept事件的处理

在Nio的事件循环中,如果select到I/O连接或读时,最终会使用服务器的NioServerSocketChannel内部的NioMessageUnsafe的read()进行处理。

private final List<Object> readBuf = new ArrayList<Object>(); // Unsafe内部变量
read() {
    try {
        do {
            int localRead = doReadMessages(readBuf); // accept建立建立,创建客户端Channel
            if (localRead == 0) {
                break;
            }
            if (localRead < 0) {
                closed = true;
                break;
            }
            allocHandle.incMessagesRead(localRead);
        } while (allocHandle.continueReading()); // 是否还有读取的数据
    } catch (Throwable t) {
        exception = t;
    }
    // 通知Pipeline
    int size = readBuf.size();
    for (int i = 0; i < size; i++) {
        readPending = false;
        pipeline.fireChannelRead(readBuf.get(i));
    }
    allocHandle.readComplete(); // 重新计算缓冲池大小
    pipeline.fireChannelReadComplete();
  1. Netty中缓冲区使用RecvByteBufAllocator和RecvByteBufAllocator.Handle来进行分配,在内存管理一节有详细说明。
  2. accept获得连接成功与客户端的javaChannel,然后创建NettyChannel,NioSocketChannel(初始化过程与NioServerSocketChannel类似,有channelID,unsafe和Pipeline),也会创建Config和AdaptiveRecvByteBufAllocator。
  3. 通知Pipeline,触发fireChannelRead,参数msg为创建的客户端通道NioSocketChannel,Head的channelRead没有实际内容,传给ServerBootstrapAcceptor,ServerBootstrapAcceptor负责将用户定义的childHandler加入到子ChannelHandler的Pipeline中。
  4. 最后,重新计算缓冲池大小(可能扩容或减小)
  5. 触发Pipeline的fireChannelReadComplete

此时,与客户端的javaChannel已经建立,并且创建了Netty的客户端NioSocketChannel,并将其注册子线程池组中,在子线程池的事件循环中,会处理read事件。

6.1.3 Accept事件处理器

在服务器启动完成后,NioServerSocketChannel的Pipeline结构如下:

Head[I/O] <--> ServerBootstrapAcceptor[IN] <--> Tail[IN]

Pipeline中的ServerBootstrapAcceptor是用来处理连接任务,其逻辑比较简单:在收到Accept后调用childHandler方法设置了ServerBootstrap的子Channel的处理器,此时会将childChannelHandler添加到子Channel中(NioSocketChannel会在连接过程中创建);设置子Channel的配置和属性;最后将子Channel注册到子线程池组中。

// 子Channel是服务器接收到请求后创建与客户端连接的通道
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    final Channel child = (Channel) msg;
    child.pipeline().addLast(childHandler); // 向子Channel添加子处理器
    // 设置子Channel的配置和属性
    for (Entry<ChannelOption<?>, Object> e : childOptions) {
        try {
            if (!child.config().setOption((ChannelOption<Object>) e.getKey(), e.getValue())) {
                logger.warn("Unknown channel option: " + e);
            }
        } catch (Throwable t) {
            logger.warn("Failed to set a channel option: " + child, t);
        }
    }
    for (Entry<AttributeKey<?>, Object> e : childAttrs) {
        child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());
    }
    try {// 将子Channel注册到子线程池组这
        childGroup.register(child).addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (!future.isSuccess()) {
                    forceClose(child, future.cause());
                }
            }
        });
    } catch (Throwable t) {
        forceClose(child, t);
    }
}

6.2 read

在与客户端建立连接时,会创建客户端通道NioSocKetChannel,并注册到子事件循环组中,由其不断select()查询就绪的I/O,然后再针对I/O进行处理。处理读操作的是NioSocketChannel的unsafe,由NioSocketChannelUnsafe实现,read()在AbstractNioByteChannel$NioByteUnsafe中。其主要的过程比较简单:

  1. 子Channel的创建过程中,其ChannelConfig会创建ByteBufAllocator,用于分配内存,默认的分配器为PooledByteBufAllocator;内存分配的过程比较复杂,在内存管理一节介绍;RecvByteBufAllocator用于计算缓冲区的大小;通过这两个对象,可以获取缓冲区byteBuf = allocHandle.allocate(allocator);
  2. doReadBytes(byteBuf)中,每次从javaChannel中读取数据;之后通知pipeline触发fireChannelRead(byteBuf);结束后判断是否还有未读取的数据,如果有则继续循环读取。
  3. 最后,allocHandle.readComplete();重新计算缓冲区大小并通知pipeline触发fireChannelReadComplete();
do {
    byteBuf = allocHandle.allocate(allocator);
    allocHandle.lastBytesRead(doReadBytes(byteBuf));
    if (allocHandle.lastBytesRead() <= 0) {
        byteBuf.release();
        byteBuf = null;
        close = allocHandle.lastBytesRead() < 0;
        break;
    }
    allocHandle.incMessagesRead(1);
    readPending = false;
    pipeline.fireChannelRead(byteBuf);
    byteBuf = null;
} while (allocHandle.continueReading());
allocHandle.readComplete();
pipeline.fireChannelReadComplete();
if (close) {
    closeOnRead(pipeline);
}

6.3 write

在Netty使用过程中,一般会在业务逻辑的ChannelInboundHandlerAdapter的channelRead中,调用ctx.write();和ctx.flush()向客户端发送数据。写入的逻辑比较简单:

  1. 查找下一个Outbound的Handler,中间可能有一些业务逻辑Handler,最终处理write的是HeadContext,如果需要flush则调用invokeWriteAndFlush,否则调用invokeWrite
  2. invokeWrite会调用unsafe的write(msg, promise); 将其加入到outboundBuffer中,这里不会flush通过网络发送;
  3. flush()方法,调用unsafe的flush();最终通过javaChannel写入网络。

作者:史圣杰

来源:https://www.jianshu.com/p/c5aa20fb5634


版权声明:文末如注明作者和来源,则表示本文系转载,版权为原作者所有 | 本文如有侵权,请及时联系,承诺在收到消息后第一时间删除 | 如转载本文,请注明原文链接。
喜欢 (0)