Netty源码分析之一次请求是如何到达channelRead的?

布满荆棘的人生 2024-04-17 05:36 36阅读 0赞

使用java nio做网络编程大致流程如下

![format_png][]

这个流程有哪些可以优化的空间？

Netty是对java网络框架的包装，它本身肯定也会有类似的处理流程。必定在这个方面做了自己的优化处理

## 获得Selector ##

使用Netty的时候都会用到对应的EventLoopGroup,它实际上就完成了Selector 的初始化过程。

> Netty自定义了SelectionKey 的集合，做了层包装，实际将 Selector 只有1个SelectorKey 的集合换成了默认的两个集合

![format_png 1][]

## 获得Channel ##

使用Netty时会执行channel 的类型，然后在执行bind方法时，此处就会对channel 实行初始化

> 构建的方式为 `class.newInstance()`,以NioServerSocketChannel为例，它执行的就是对应的无参构造函数。

public NioServerSocketChannel() {
     		//newSocket即返回java的ServerSocketChannel
            this(newSocket(DEFAULT_SELECTOR_PROVIDER));
     }
     public NioServerSocketChannel(ServerSocketChannel channel) {
     		//指定当前channel用来接收连接请求,并在父类中指定为非阻塞
            super(null, channel, SelectionKey.OP_ACCEPT);
            //javaChannel()即这里的参数channel
            config = new NioServerSocketChannelConfig(this, javaChannel().socket());
    }

紧接着Netty开始channel的初始化，在NioServerSocketChannel 的pipeline最后添加了一个`ChannelInboundHandlerAdapter`即`ServerBootstrapAcceptor`,它会执有 `childGroup `和`childHandler`，childHandler即用户自定义的channelHandler,而childGroup则是处理请求所用的EventLoop,此时整个pipeline的结构为

> childGroup为源码中字段的命名，对应为group中传递的worker线程池

![format_png 2][]

# #

## channel的注册与监听端口地址关联 ##

注册即建立channel 和Selector 的关系，值得注意的是，注册使用的线程池为`group`,对应用户传入的线程池即boss线程池，注册和端口、地址关联则顺着Netty的启动流程进行

> 至此可以看到，java nio所需要的准备工作都已经准备好了，剩下的就是等待事件发生以及处理发生的事件。与普通java nio的不同之处在于
> 
>  *  Netty准备了两个线程池，channel注册、端口绑定监听的只用到了其中同一个线程池

## 等待事件发生 ##

NioEventLoop 实现了Executor，意味着它接受其它地方提交任务 给它执行,execute的大致结构如下

//判断当前正在执行的线程是否是Netty自己的eventLoop中保存的线程
    boolean inEventLoop = inEventLoop();
      if (inEventLoop) {
        //往队列里添加任务
      	addTask(task);
      } else {
      	//这里即运行NioEventLoop自身的run方法
    	startThread();
      	addTask(task);
      }

NioEventLoop启动线程执行run方法，整体结构如下

for (;;) {
     if (hasTasks()) {
        selectNow();
       } else {
        select(oldWakenUp);
       }
      processSelectedKeys();
      runAllTasks();
    }

run循环处理的流程如下

![format_png 3][]

值得注意的是，这是`单个线程在运行，而且非本线程的任务一概不处理`

### boss线程的启动时机 ###

在启动的过程中，由ServerBootstrap来串起整个流程，它的执行线程为主线程，而注册事件都是交由线程池自己来执行的，用程序表达来讲，就是执行了eventLoop自己的execute,此时执行线程必定不是EventLoop自己的线程，从而boss中的线程启动，在队列任务中完成注册

## 新连接请求的到来 ##

当NioServerSocketChannel绑定了端口之后，NioServerSocketChannel对应的NioEventLoop会等待channel发生事件。整个处理流程如下

![format_png 4][]

1.  读取消息的内容，发生在NioServerSocketChannel，对于这个新的连接事件，则包装成一个客户端的请求channel作为后续处理
    
        protected int doReadMessages(List<Object> buf) throws Exception {
         		//1:获取请求的channel
                SocketChannel ch = javaChannel().accept();
        
                try {
                    if (ch != null) {
                    	//2:包装成一个请求，Socket channel返回
                        buf.add(new NioSocketChannel(this, ch));
                        return 1;
                    }
                } catch (Throwable t) {
                    logger.warn("Failed to create a new channel from an accepted socket.", t);
        
                    try {
                        ch.close();
                    } catch (Throwable t2) {
                        logger.warn("Failed to close a socket.", t2);
                    }
                }
        
                return 0;
            }
2.  返回的NioSocketChannel则完成自身channel的初始化，注册感兴趣的事件
    
        protected AbstractNioByteChannel(Channel parent, SelectableChannel ch) {
                super(parent, ch, SelectionKey.OP_READ);
        }

回想到boss中的下一环即`ServerBootstrapAcceptor`,而它读取消息的处理则是添加用户自己的handler,并继续完成注册事件

public void channelRead(ChannelHandlerContext ctx, Object msg) {
                final Channel child = (Channel) msg;
    
                child.pipeline().addLast(childHandler);
    
                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 {
                    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);
                }
            }

### worker线程的启动时机 ###

worker 的注册发生在boss的线程执行中，此刻必定不是同一个线程，因而开始启动worker的线程，并在内部完成注册事件，等待读消息的到来

### OP\_read消息处理 ###

连接建立后的请求则是交由`NioSocketChannel`来处理，它将读到的消息封装成ByteBuf,通过`InBound`处理器`fireChannelRead`依次传给其它的地方消费，一直到tailContext消息处理完毕

> 此处也可以得知管道的 in 表示数据传入netty，回写则是通过 out 一直到Head然后写入channel

## Netty中Nio的处理流程 ##

从上述分析可以得到，Netty的处理流程如下

![format_png 5][]

### boss是否需要多个线程 ###

[mainReactor 多线程配置 ][mainReactor _] ，对于多个端口监听是有益的，当然1个也可以处理多端口

## Reactor模式 ##

CPU的处理速度快于IO处理速度，在处理事情时，最佳情况是CPU不会由于IO处理而遭到阻塞，造成CPU的”浪费“，当然可以用多线程去处理IO请求，但是这会增加线程的上下文切换，切换过去可能IO操作也还没有完成，这也存在浪费的情况。

另一种方式是：当IO操作完成之后，再通知CPU进行处理。那谁来知晓IO操作完成？并将事件讲给CPU处理呢？在Reactor模式中，这就是Reactor的作用，它启动一个不断执行的线程来等待IO发生，并按照事件类型，分发给不同的事先注册好的事件处理器来处理

Reactor模式抽象如下

![format_png 6][]

**参考：**

[http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf][http_gee.cs.oswego.edu_dl_cpjslides_nio.pdf]

[https://github.com/code4craft/netty-learning/blob/master/posts/ch4-reactor.md][https_github.com_code4craft_netty-learning_blob_master_posts_ch4-reactor.md]

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS8zLzEzLzE2OTc2MmUzYjE1ZWU5OGU_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS8zLzEzLzE2OTc2MzlhYmU3M2Q5YzY_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS8zLzEzLzE2OTc2NDE4OTlmNzI2ZmU_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS8zLzEzLzE2OTc2NTk1MTZmNjU2NGU_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS8zLzEzLzE2OTc2NjhlNWQ2MmMwZWU_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS8zLzEzLzE2OTc2N2ZmNzgwZmQzOGU_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png
[mainReactor _]: https://link.juejin.im?target=https%3A%2F%2Fstackoverflow.com%2Fquestions%2F34275138%2Fwhy-do-we-really-need-multiple-netty-boss-threads
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS8zLzEzLzE2OTc2ODU2YjEzZjBjYTU_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png
[http_gee.cs.oswego.edu_dl_cpjslides_nio.pdf]: http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf
[https_github.com_code4craft_netty-learning_blob_master_posts_ch4-reactor.md]: https://github.com/code4craft/netty-learning/blob/master/posts/ch4-reactor.md