Netty服务端启动源码解析

前言

前面写了一系列关于NIO和Netty基础相关的文章，对于学好Netty最主要的是什么呢？那应该是需要先学好NIO和理解Netty中的Reactor线程模型，还有关于网络编程方面的一些只是，譬如封帧、编解码等。

那么本篇文章就开始进行Netty源码的解析了，对于Netty源码的解析，我们还是先从代码运行链路的角度来进行源码解析，在进行源码解析之前，我们还需要先看下Netty Reactor线程模型图，如下：

上图中的含义大体如下：

• 创建两组线程池BossGroup和WorkerGroup，BossGroup负责接受客户端的连接，WorkerGroup负责网路读写和处理业务逻辑。BossGroup和WorkerGroup的类型都是NioEventLoop。
• NioEventLoopGroup相当于一个事件循环线程组，这个组中含有多个事件循环线程，每个事件循环线程为一个NioEventLoop。
• 每一个NioEventLoop中都包含一个Selector，适用于监听注册在其上的SocketChannel的网络通讯。
• 每个Boss NioEventLoop 线程内部的执行步骤如下：
  • 处理accept事件，与client建立连接，，生成NioSocketChannel。
  • 将NioSocketChannel注册到每个 Worker NioEventLoop中的Selector上。
  • 处理任务队列的任务：runAllTask。
• 每个Worker NioEventLoop 线程内部的执行步骤如下：
  • 轮询注册到自己Selector上的所有NioSocketChannel的read、write事件。
  • 处理IO事件：read和write事件，在对应的NioScoketChannel中处理业务。
  • runAllTask处理任务队列TaskQueue的任务，一些耗时较长的任务可以放到TaskQueue中慢慢处理，但这不影响数据在pipeline中的流动处理。
• 每个Worker NioEventLoop 处理NioSocketChannel业务时，会使用到pipeline（管道），管道中维护了很多Handler来处理Channel中的数据。

Netty示例代码

在了解完Netty Reactor的相关概念之后，那么我们再来看一下关于Netty 使用的示例代码（本示例代码依赖的netty版本为：4.1.35.Final），如下：

Netty Server端示例代码

public class NettyServer {
    public static void main(String[] args) throws Exception {

        //创建两个线程组：bossGroup和workGroup
        //bossGroup 只处理连接请求，真正的和客户端的业务处理，是交由workGroup处理的
        EventLoopGroup bossGroup = new NioEventLoopGroup(3);
        EventLoopGroup workerGroup = new NioEventLoopGroup(8);

        try {
            // 创建服务器端的启动对象
            ServerBootstrap bootstrap = new ServerBootstrap();
            // 使用链式编程来配置参数
            bootstrap.group(bossGroup, workerGroup) //设置两个线程组
                    // 使用NioServerSocketChannel作为服务器的通道实现
                    .channel(NioServerSocketChannel.class)
                    // 初始化服务器连接队列大小，服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。
                    // 多个客户端同时来的时候,服务端将不能处理的客户端连接请求,将放在队列中等待处理
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    //创建通道初始化对象，设置初始化参数，在 SocketChannel 建立起来之前执行
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            //对workerGroup的SocketChannel设置处理器
                            socketChannel.pipeline().addLast(new NettyServerHandler());
                        }
                    });

            System.out.println("netty server start。。");


            ChannelFuture channelFuture = bootstrap.bind(9000).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

 NettyServerHandler

public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 当客户端连接服务器完成就会触发该方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        System.out.println("客户端连接通道建立完成");
    }

    /**
     * 读取客户端发送的数据
     * @param ctx  上下文对象, 含有通道channel，管道pipeline
     * @param msg  就是客户端发送的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        //将 msg 转成一个 ByteBuf，类似NIO 的 ByteBuffer
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("收到客户端的消息:" + buf.toString(CharsetUtil.UTF_8));
    }

    /**
     * 数据读取完毕处理方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ByteBuf buf = Unpooled.copiedBuffer("HelloClient".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(buf);
    }

    /**
     * 处理异常, 一般是需要关闭通道
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        ctx.close();
    }
}

Netty Client端示例代码

public class NettyClient {
    public static void main(String[] args) throws Exception {

        //客户端需要一个事件循环组
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //创建客户端启动对象
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group) //设置线程组
                    .channel(NioSocketChannel.class) // 使用NioSocketChannel作为客户端的通道实现
                    .handler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            //加入处理器
                            socketChannel.pipeline().addLast(new NettyClientHandler());
                        }
                    });
            System.out.println("netty client start。。");
            //启动客户端去连接服务器端
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 9000).sync();
            //对通道关闭进行监听
            cf.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

NettyClientHandler

public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    /**
     * 当客户端连接服务器完成就会触发该方法
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ByteBuf buf = Unpooled.copiedBuffer("HelloServer".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(buf);
    }

    //当通道有读取事件时会触发，即服务端发送数据给客户端
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("收到服务端的消息:" + buf.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

上面展示了一下，关于Netty 使用的示例代码，本系列所有的代码解析都是从这些示例代码中出发的，当然前面的那张Netty Reactor线程模型图也是很重要的，需要读者详细了解，其中的相关关联关系，才能更好的深入了解Nettyd 源码。

因为本篇文章主要讲的是关于Netty 服务端启动源码的解析，所以这需要从 NettyServer 端的 bootstrap.bind(9000).sync() 这段代码开始入手，至于前面的EventLoopGroup、NioEventLoopGroup、ServerBootstrap、Bootstrap等相关组件的架构关系源码解析，后面将会用单独的篇章进行解析。

Netty服务注册

这里我们先看一下启动核心服务的时序图，从下图中可以清晰的看出关于NettyServer端示例代码中的主要流程，包括以下步骤：

• 创建Boss NioEventLoopGroup
• 创建多个Boss NioEventLoop，然后再每个Boss NioEventLoop上绑定一个Selector
• 创建ServerBootstrap，并绑定端口及启动服务器
• 创建NioServerSocketChannel
• 初始化NioServerSocketChannel
• 分配BossNioEventLoop
• 注册NioServerSocketChannel到BossNioEventLoop里的Selector上
• NioServerSocketChannel绑定端口
• 注册NioServerSocketChannel的“读”事件

创建NioEventLoopGroup

从前面的示例中也是知道在Netty编程中，需要先创建一个Boss NioEventLoopGroup，在这个对象创建的时候会创建多个（这个多个是指自己传入或者根据CPU核心数进行相关计算的）NioEventLoop，在创建NioEventLoop时候，同时会绑定Selector，我们来看下代码的具体实现，如下：

// nThreads 参数是指传入的“多个”，可根据传入的数值来创建对应数量的NioEventLoop
public NioEventLoopGroup(int nThreads) {
    this(nThreads, (Executor)null);
}

public NioEventLoopGroup(int nThreads, Executor executor) {
    // SelectorProvider.provider() 便是Nio编程中创建Selector的方式
    this(nThreads, executor, SelectorProvider.provider());
}

public NioEventLoopGroup(int nThreads, Executor executor, SelectorProvider selectorProvider) {
    this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
}

public NioEventLoopGroup(int nThreads, Executor executor, SelectorProvider selectorProvider, SelectStrategyFactory selectStrategyFactory) {
    super(nThreads, executor, new Object[]{selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject()});
}

protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    // 判断是否传入了 nThreads，如果没传，则使用默认的参数，否则根据传入的参数创建
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
    this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}

MultithreadEventExecutorGroup#MultithreadEventExecutorGroup(int, java.util.concurrent.Executor, io.netty.util.concurrent.EventExecutorChooserFactory, java.lang.Object...)

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, Object... args) {
    this.terminatedChildren = new AtomicInteger();
    this.terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    } else {
        // 如果没有传入 executor，则创建 ThreadPerTaskExecutor
        if (executor == null) {
            executor = new ThreadPerTaskExecutor(this.newDefaultThreadFactory());
        }
        // 根据传入nThreads的数量，创建线程池数组，并赋值给 children
        this.children = new EventExecutor[nThreads];

        int j;
        // 根据传入nThreads的数量，循环创建 NioEventLoop
        for(int i = 0; i < nThreads; ++i) {
            boolean success = false;
            boolean var18 = false;
            try {
                var18 = true;
                // 创建 NioEventLoop
                this.children[i] = this.newChild((Executor)executor, args);
                success = true;
                var18 = false;
            } catch (Exception var19) {
                throw new IllegalStateException("failed to create a child event loop", var19);
            } finally {
                // 省略非关键代码
            }
    	// 省略非关键代码
        }
        // 获取 chooser
        this.chooser = chooserFactory.newChooser(this.children);
        FutureListener