【云原生】谈谈Netty的线程模型

Reactor 线程模型:

1. Reactor 是反应堆的意思，Reactor 模型是指通过一个或多个输入同时传递给服务处理器的服务请求的事件驱动处理模式。服务端程序处理传入多路请求，并将它们同步分派给请求对应的处理线程，Reactor 模式也叫 Dispatcher 模式，即 I/O 多了复用统一监听事件，收到事件后分发(Dispatch 给某进程)，是编写高性能网络服务器的必备技术之一。

2. Reactor 模型中有 2 个关键组:

   1. Reactor：Reactor 在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对 IO 事件做出反应。它就像公司的电话接线员，它接听来自客户的电话并将线路转移到适当的联系人；
   2. Handlers：处理程序执行 I/O 事件要完成的实际事件，类似于客户想要与之交谈的公司中的实际官员。Reactor 通过调度适当的处理程序来响应 I/O 事件，处理程序执行非阻塞操作。

   

3. 取决于 Reactor 的数量和 Hanndler 线程数量的不同，Reactor 模型有 3 个变种：

   1. 单 Reactor 单线程；
   2. 单 Reactor 多线程；
   3. 主从 Reactor 多线程。
   4. 可以这样理解，Reactor 就是一个执行 while (true) { selector.select(); …} 循环的线程，会源源不断的产生新的事件，称作反应堆很贴切

Netty 线程模型:

1. Netty 主要基于主从 Reactors 多线程模型（如下图）做了一定的修改，其中主从 Reactor 多线程模型有多个 Reactor：

   1. MainReactor 负责客户端的连接请求，并将请求转交给 SubReactor；
   2. SubReactor 负责相应通道的 IO 读写请求；
   3. 非 IO 请求（具体逻辑处理）的任务则会直接写入队列，等待 worker threads 进行处理。

2. 主从 Reactor 多线程模型的图：

   

   特别说明的是：虽然 Netty 的线程模型基于主从 Reactor 多线程，借用了 MainReactor 和SubReactor 的结构。但是实际实现上 SubReactor 和 Worker 线程在同一个线程池中：

   EventLoopGroup bossGroup = new NioEventLoopGroup();
   EventLoopGroup workerGroup = new NioEventLoopGroup();
   ServerBootstrap server = new ServerBootstrap();
   server.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
   

   上面代码中的 bossGroup 和 workerGroup 是 Bootstrap 构造方法中传入的两个对象，这两个 group 均是线程池：

   1. bossGroup 线程池则只是在 Bind 某个端口后，获得其中一个线程作为 MainReactor，专门处理端口的 Accept 事件，每个端口对应一个 Boss 线程；

   2. workerGroup 线程池会被各个 SubReactor 和 Worker 线程充分利用。

Netty 框架的架构设计*

1. 功能特性:

   1. 传输服务：支持 BIO 和 NIO；
   2. 容器集成：支持 OSGI、JBossMC、Spring、Guice 容器；
   3. 协议支持：HTTP、Protobuf、二进制、文本、WebSocket 等一系列常见协议都支持。还支持通过实行编码解码逻辑来实现自定义协议；
   4. Core 核心：可扩展事件模型、通用通信 API、支持零拷贝的 ByteBuf 缓冲对象。

   

2. 模块组件:

   1. Bootstrap、ServerBootstrap：Bootstrap 意思是引导，一个 Netty 应用通常由一个 Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中 Bootstrap 类是客户端程序的启动引导类, ServerBootstrap 是服务端启动引导类。

   2. Future、ChannelFuture：在 Netty 中所有的 IO 操作都是异步的，不能立刻得知消息是否被正确处理。但是可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过 Future 和ChannelFutures，他们可以注册一个监听，当操作执行成功或失败时监听会自动触发注册的监听事件。

   3. Channel：Netty 网络通信的组件，能够用于执行网络 I/O 操作。Channel 为用户提供:

      1. 当前网络连接的通道的状态（例如是否打开？是否已连接？）
      2. 网络连接的配置参数 （例如接收缓冲区大小）
      3. 提供异步的网络 I/O 操作(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即返回，并且不保证在调用结束时所请求的 I/O 操作已完成。
      4. 调用立即返回一个 ChannelFuture 实例，通过注册监听器到 ChannelFuture 上，可以I/O 操作成功、失败或取消时回调通知调用方。
      5. 支持关联 I/O 操作与对应的处理程序。
      6. 常用的 Channel 类型：
         1. NioSocketChannel，异步的客户端 TCP Socket 连接。
         2. NioServerSocketChannel，异步的服务器端 TCP Socket 连接。
         3. NioDatagramChannel，异步的 UDP 连接。
         4. NioSctpChannel，异步的客户端 Sctp 连接。
         5. NioSctpServerChannel，异步的 Sctp 服务器端连接，这些通道涵盖了 UDP 和 TCP 网络 IO 以及文件 IO。

   4. Selector：Netty 基于 Selector 对象实现 I/O 多路复用，通过Selector 一个线程可以监听多个连接的 Channel 事件。当向一个 Selector 中注册 Channel 后，Selector 内部的机制就可以自动不断地查询(Select) 这些注册的 Channel 是否有已就绪的 I/O 事件（例如可读，可写，网络连接完成等），这样程序就可以很简单地使用一个线程高效地管理多个 Channel 。

   5. NioEventLoop：NioEventLoop 中维护了一个线程和任务队列，支持异步提交执行任务，线程启动时会调用NioEventLoop 的 run 方法，执行 I/O 任务和非 I/O 任务：

      1. I/O 任务，即 selectionKey 中 ready 的事件，如 accept、connect、read、write 等，由 processSelectedKeys 方法触发。
      2. 非 IO 任务，添加到 taskQueue 中的任务，如 register0、bind0 等任务，由 runAllTasks方法触发。两种任务的执行时间比由变量ioRatio 控制，默认为 50，则表示允许非 IO 任务执行的时间与 IO 任务的执行时间相等。

   6. NioEventLoopGroup：NioEventLoopGroup，主要管理 eventLoop 的生命周期，可以理解为一个线程池，内部维护了一组线程，每个线程(NioEventLoop)负责处理多个 Channel 上的事件，而一个 Channel只对应于一个线程。

   7. ChannelHandler：ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其ChannelPipeline(业务处理链)中的下一个处理程序。ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类：

      1. ChannelInboundHandler 用于处理入站 I/O 事件。
      2. ChannelOutboundHandler 用于处理出站 I/O 操作。
      3. 或者使用以下适配器类：
         1. ChannelInboundHandlerAdapter 用于处理入站 I/O 事件。
         2. ChannelOutboundHandlerAdapter 用于处理出站 I/O 操作。
         3. ChannelDuplexHandler 用于处理入站和出站事件。

   8. ChannelHandlerContext：保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象.

   9. ChannelPipline：保存 ChannelHandler 的 List，用于处理或拦截Channel 的入站事件和出站操作。ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及 Channel 中各个的 ChannelHandler 如何相互交互。

      1. 在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应，它们的组成关系如下：

         

      2. 一个 Channel 包含了一个 ChannelPipeline，而 ChannelPipeline 中又维护了一个由ChannelHandlerContext 组成的双向链表，并且每个 ChannelHandlerContext 中又关联着一个 ChannelHandler。

      3. 入站事件和出站事件在一个双向链表中，入站事件会从链表 head 往后传递到最后一个入站的 handler，出站事件会从链表 tail 往前传递到最前一个出站的 handler，两种类型的handler 互不干扰。

Netty 框架的工作原理:

1. 并启动 Netty 服务端的过程代码

   public static void main(String[] args) {
       // 创建 mainReactor
       NioEventLoopGroup boosGroup = new NioEventLoopGroup();
       // 创建工作线程组
       NioEventLoopGroup workerGroup = newNioEventLoopGroup();
       final ServerBootstrap serverBootstrap = new ServerBootstrap();
       serverBootstrap
           // 组装 NioEventLoopGroup
           .group(boosGroup, workerGroup)
           // 设置 channel 类型为 NIO 类型
           .channel(NioServerSocketChannel.class)
           // 设置连接配置参数
           .option(ChannelOption.SO_BACKLOG, 1024)
           .childOption(ChannelOption.SO_KEEPALIVE, true)
           .childOption(ChannelOption.TCP_NODELAY, true)
           // 配置入站、出站事件 handler
           .childHandler(new ChannelInitializer<NioSocketChannel>() {
               @Override
               Protected void initChannel(NioSocketChannel
               ch)
               {
               // 配置入站、出站事件 channel
               ch.pipeline().addLast(...);
               ch.pipeline().addLast(...);
               }
           });
       // 绑定端口
       int port = 8080;
       serverBootstrap.bind(port).addListener(future -> {
       if(future.isSuccess()) {
           System.out.println(newDate() + ": 端口["+ port + "]绑定成功!");
       } else{
       	System.err.println("端口["+ port + "]绑定失败!");
       }
       });
   }
   

   基本过程描述如下：

   1. 初始化创建 2 个 NioEventLoopGroup：其中 boosGroup 用于 Accetpt 连接建立事件并分发请求，workerGroup 用于处理 I/O 读写事件和业务逻辑。
   2. 基于 ServerBootstrap(服务端启动引导类)：配置 EventLoopGroup、Channel 类型，连接参数、配置入站、出站事件 handler。
   3. 绑定端口：开始工作。

2. 服务端 Netty 的工作架构图: Server 端包含 1 个 Boss NioEventLoopGroup 和 1 个 Worker NioEventLoopGroup。NioEventLoopGroup 相当于 1 个事件循环组，这个组里包含多个事件循环 NioEventLoop，每个 NioEventLoop 包含 1 个 Selector 和 1 个事件循环线程。

   

   1. 每个 Boss NioEventLoop 循环执行的任务包含 3 步：

      1. 轮询 Accept 事件；
      2. 处理 Accept I/O 事件，与 Client 建立连接，生成NioSocketChannel，并将NioSocketChannel 注册到某个 Worker NioEventLoop 的 Selector 上；
      3. 处理任务队列中的任务，runAllTasks。任务队列中的任务包括用户调用eventloop.execute 或 schedule 执行的任务，或者其他线程提交到该 eventloop 的任务。

   2. 每个 Worker NioEventLoop 循环执行的任务包含 3 步：

      1. 轮询 Read、Write 事件；
      2. 处理 I/O 事件，即 Read、Write 事件，在 NioSocketChannel 可读、可写事件发生时进行处理；
      3. 处理任务队列中的任务，runAllTasks。

   3. 任务队列中的 Task 有 3 种典型使用场景：

      1. 用户程序自定义的普通任务：

         ctx.channel().eventLoop().execute(new Runnable() {
             @Override
             public void run() {
                 //...
                 }
         });
         

      2. 非当前 Reactor 线程调用 Channel 的各种方法：例如在推送系统的业务线程里面，根据用户的标识，找到对应的 Channel 引用，然后调用
         Write 类方法向该用户推送消息，就会进入到这种场景。最终的 Write 会提交到任务队列中后被异步消费。

      3. 用户自定义定时任务：

         ctx.channel().eventLoop().schedule(new Runnable() {
             @Override
             public void run() {
             }
         }, 60, TimeUnit.SECONDS);