Netty

Netty工作流程图

1. Netty 抽象出两组线程池BossGroup和WorkerGroup，Boss专门负责接收客户端的连接,Worker专门负责网络的读写
2. BossGroup和WorkerGroup类型都是NioEventLoopGroup
3. NioEventLoopGroup 相当于一个事件循环线程组, 这个组中含有多个事件循环线程 ， 每一个事件循环线程是NioEventLoop
4. 每个NioEventLoop都有一个selector , 用于监听注册在其上的socketChannel的网络通讯
5. 每个Boss NioEventLoop线程内部循环执行的步骤有 3 步

• 处理accept事件 , 与client 建立连接 , 生成 NioSocketChannel
• 将NioSocketChannel注册到某个worker NIOEventLoop上的selector
• 处理任务队列的任务 ， 即runAllTasks

6. 每个worker NIOEventLoop线程循环执行的步骤

• 轮询注册到自己selector上的所有NioSocketChannel 的read, write事件
• 处理 I/O 事件， 即read , write 事件， 在对应NioSocketChannel 处理业务
• runAllTasks处理任务队列TaskQueue的任务 ，一些耗时的业务处理一般可以放入TaskQueue中慢慢处理，这样不影响数据在 pipeline 中的流动处理

7. 每个worker NIOEventLoop处理NioSocketChannel业务时，会使用 pipeline (管道)，管道中维护了很多 handler 处理器用来处理 channel 中的数据

Netty几个组件

• NioEventLoopGroup 主要用于处理连接，消息事务等

  
  

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

• Channel：
  Netty 网络通信的组件，能够用于执行网络 I/O 操作。
  channel里面包含ChannelPipline，
  ChannelPipline里面包含ChannelHandlerContext列表
  ChannelHandlerContext里面包含ChannelHandler等

  
  

• ChannelPipline：
  保存 ChannelHandlerContext的 List，用于处理或拦截 Channel 的入站事件和出站操作。 一个 Channel 包含了一个 ChannelPipeline，而 ChannelPipeline 中又维护了一个由 ChannelHandlerContext 组成的双向链表，并且每个 ChannelHandlerContext 中又关联着一个 ChannelHandler。
  read，write拦截链执行顺序：read事件(入站事件)和write事件(出站事件)在一个双向链表中，入站事件会从链表 head 往后传递到最后一个入站的 handler，出站事件会从链表 tail 往前传递到最前一个出站的 handler，两种类型的 handler 互不干扰。

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

• ChannelHandler：
  真正负责处理 I/O 事件或拦截 I/O 操作的地方，并将其转发到其 ChannelPipeline(业务处理链)中的下一个处理程序。

主要流程图

引用网上的一张图

Netty线程模型源码剖析

我们先来看服务端，服务端源码入口（一个简单的netty服务端代码）

public class NettyServer {
    public static void main(String[] args) throws Exception {
        //创建两个线程组bossGroup和workerGroup, 含有的子线程NioEventLoop的个数默认为cpu核数的两倍
        // bossGroup只是处理连接请求 ,真正的和客户端业务处理，会交给workerGroup完成
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //创建服务器端的启动对象
            ServerBootstrap bootstrap = new ServerBootstrap();
            //使用链式编程来配置参数
            bootstrap.group(bossGroup, workerGroup) //设置两个线程组
                    .channel(NioServerSocketChannel.class) //使用NioServerSocketChannel作为服务器的通道实现
                    // 初始化服务器连接队列大小，服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。
                    // 多个客户端同时来的时候,服务端将不能处理的客户端连接请求放在队列中等待处理
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer() {//创建通道初始化对象，设置初始化参数
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //对workerGroup的SocketChannel设置处理器
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });
            System.out.println("netty server start。。");
            //绑定一个端口并且同步, 生成了一个ChannelFuture异步对象，通过isDone()等方法可以判断异步事件的执行情况
            //启动服务器(并绑定端口)，bind是异步操作，sync方法是等待异步操作执行完毕
            ChannelFuture cf = bootstrap.bind(9000).sync();
            //对通道关闭进行监听，closeFuture是异步操作，监听通道关闭
            // 通过sync方法同步等待通道关闭处理完毕，这里会阻塞等待通道关闭完成
            cf.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}
我们先来看ChannelFuture cf = bootstrap.bind(9000).sync();之前初始化一些参数的代码

EventLoopGroup bossGroup = new NioEventLoopGroup();

//----------------------------------✂------------------------------------------

EventLoopGroup bossGroup = new NioEventLoopGroup();

创建bossGroup和workerGroup ，最后是调用到MultithreadEventExecutorGroup这个方法
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
        if (executor == null) {
           //新建一个executor
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }
        //根据传入的子线程数来创建线程池executor
        children = new EventExecutor[nThreads];
        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                //这边主要是创建一个NioEventLoop，具体结构可参考最上面的图，这边比较重要下面详解
                children[i] = newChild(executor, args);
                success = true;
            } catch (Exception e) {
                // TODO: Think about if this is a good exception type
                throw new IllegalStateException("failed to create a child event loop", e);
            } finally {
                if (!success) {
                    for (int j = 0; j < i; j ++) {
                        children[j].shutdownGracefully();
                    }

                    for (int j = 0; j < i; j ++) {
                        EventExecutor e = children[j];
                        try {
                            while (!e.isTerminated()) {
                                e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                            }
                        } catch (InterruptedException interrupted) {
                            // Let the caller handle the interruption.
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }
        }

        chooser = chooserFactory.newChooser(children);

        final FutureListener