Netty源码分析-06 Netty读写流程

在服务器启动过程初,我们向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 readBuf = new ArrayList(); // 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, Object> e: childOptions) {
        try {
            if (!child.config().setOption((ChannelOption) 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, Object> e: childAttrs) {
        child.attr((AttributeKey) 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写入网络;

你可能感兴趣的:(Netty源码分析-06 Netty读写流程)