Netty启动的那点事（一）

背景

       对于netty一直比较好奇，之前看过《Netty权威指南》、《Netty实战》，但是可能因为自己对于netty没有很好的实践感受，才促使自己深入学习，也可能对于没有静下心来，多种原因吧。

       新年伊始，刚好年前一段时间对于netty也进去了项目上手，自己也能静下来一行一行阅读源码。

启动Netty服务端代码

public class HelloWorldServer {
    private int port;

    public HelloWorldServer(int port){
        this.port = port;
    }

    public void start(){
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();
        try{
            //group指定ServerBootstrap的parentGroup 为bossGroup
            //childGroup为woker
            ServerBootstrap serverBootstrap = new ServerBootstrap().group(bossGroup, worker)
            //channel调用的是ServerBootstrap的父类AbstractBootstrap，作用是初始化serverBootstrap的channelFactory，
            // 里面的参数表示以后创建出来的channel为NioServceSocketChannle对象，channel返回的是serverBootstrap对象
            .channel(NioServerSocketChannel.class)
            //给serverBootstrap初始化localAddress属性
            .localAddress(new InetSocketAddress(port))
            //初始化childHandler,返回serverBootstrap
            .childHandler(new ChannelInitializer() {
                        protected void initChannel(SocketChannel ch) throws Exception {
//                            ch.pipeline().addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
                            ch.pipeline().addLast("decoder", new StringDecoder());
                            ch.pipeline().addLast("encoder", new StringEncoder());
                            ch.pipeline().addLast(new HelloWorldServerHandler());
                        };
                    })
            //给serverBootstrap中的option赋值,方法为AbstractBootstrap中的
            //option -->new LinkedHashMap, Object>();
            .option(ChannelOption.SO_BACKLOG, 128)
            //给serverBootstrap中childOption赋值，方法为ServerBootstrap中的
            //childOption -->new LinkedHashMap, Object>();
            .childOption(ChannelOption.SO_KEEPALIVE, true);
            // 绑定端口，开始接收进来的连接
            //调用父类AbstractBootstrap中的bind
            //bind首先判断group和channelFactory是否为空，根据这个可知，这2个属性为必须的
            //最终调用AbstractBootstrap.doBind(localAddress); localAddress为.localAddress方法初始化的
            //doBind(final SocketAddress localAddress):
            // bind()返回的是DefaultChannelPromise对象
            //sync()只是让ChannelFuture挂起
            ChannelFuture future = serverBootstrap.bind(port).sync();

            System.out.println("Server start listen at " + port );
            future.channel().closeFuture().sync();

        }catch (Exception ex){
            ex.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new HelloWorldServer(port).start();
    }
}

这是一个启动Netty服务端的一代码，那么接下来进行一行行分析代码：

首先分析创建group：

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup worker = new NioEventLoopGroup();    

根据调用的栈关系，可以看到：

最终进入了MultithreadEventExecutorGroup,

//nThreads，不指定的话，默认根据cpu核数的*2，类别线程池理解的话，这是核心线程数
//executor,调度线程工作的线程池，创建正在工作的线程
//chooserFactory,分配线程池的选择器
//args，可能会有2个，一个是maxPendingTasks，填充工作队列，一个是rejectedExecutionHandler，线程池的拒绝策略概念
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 {
                //如果是NioEventLoop,那么最终创建的是SingleThreadEventLoop
                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里面
                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;
                        }
                    }
                }
            }
        }
        //选择分配线程的Executor
        //如果是2的幂的话，顺序选择根据 & 选择
        //如果是不是的话，则取余数
        //会有针对2的幂专门设计一个用 & ，这个细节可以分配线程的效率
        chooser = chooserFactory.newChooser(children);
        //为children设置监听Future
        final FutureListener