Netty源码之ServerBootstrap启动原理

前言

阅读netty源码之前建议先了解下netty相关的线程模型，推荐Doug Lea的Scalable IO in Java。并且熟悉java NIO的基本使用。

启动流程

下面是一个常见的netty启动方法：

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

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup(8);
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            //向pipeline加入解码器
                            pipeline.addLast("decoder", new StringDecoder());
                            //向pipeline加入编码器
                            pipeline.addLast("encoder", new StringEncoder());
                            //加入自己的业务处理handler
                            pipeline.addLast(new ServerHandler());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

        首先创建两个循环线程组：bossGroup和workerGroup 。这是netty中两个执行任务的循环线程组，bossGroup负责处理accept事件，workerGroup负责处理read\write事件。这里bossGroup为单线程，也是通常的做法，除非你想开启多个netty监听端口；workerGroup一般会创建多个线程来处理事件。循环线程组中的每个线程（EventLoop）内部都会有自己的多路复用器Selector，bossGroup内部的Selector处理客户端连接事件，然后把客户端连接过来的socket注册到workerGroup中某个线程的Selector上，并绑定read\write事件。

        下面先看EventLoop的创建过程：

public NioEventLoopGroup(int nThreads) {
        this(nThreads, (Executor) null);
}
//这里会调用一些列构造方法以及父类的构造方法，最后来到父类MultithreadEventExecutorGroup的构造方法

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
        if (nThreads <= 0) {
            throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
        }

        if (executor == null) {
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }
        //事件执行器，对应循环线程组中每一个循环线程，可以理解为真正干活的线程，这里为一个数组
        children = new EventExecutor[nThreads];

        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                //依次为数组中的每个执行器创建循环线程
                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;
                        }
                    }
                }
            }
        }
        //创建循环线程组中的线程选择器，可以理解为负载均衡，netty会轮询选择group中的一个线程执行任务，当线程数为2的次幂和不是2的次幂是使用不同的策略，主要因为是2的次幂时可以用按位与替代取模
        chooser = chooserFactory.newChooser(children);

        final FutureListener