Netty Server端启动之源码分析

---

本文基于上一篇Netty Server端实现，以解读源码的方式带领大家理解Server端是如何启动的，主要包括以下几点

1. EventLoopGroup类的作用是什么？为什么要new两个EventLoopGroup实例

2. ServerBootstrap类的作用是什么？以及它的build模式中如group()方法，channel()方法，childHandler()方法的分别做了哪些事？

3. ServerBootstrap的bind方法做了哪些事？

4. ChannelFuture 接口的作用是什么？

接下来我们围绕这几个点一一去分析，先贴一下整个Server启动的代码，方便我们分析

public class Server {

// 监听端口
private int port;
private Server(int port) {
    this.port = port;
}

// 启动一个Server服务器
private void start() throws InterruptedException {
    // 1.
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try {
        // 2.
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap.group(bossGroup, workerGroup)
                // 3.
                .channel(NioServerSocketChannel.class)
                // 4.
                .childHandler(new ChannelInitializer() {
                    @Override
                    protected void initChannel(SocketChannel ch) {
                        ch.pipeline().addLast(new ServerInboundHandler());
                    }
                })
                // 5.
                .option(ChannelOption.SO_BACKLOG, 128)
                // 6.
                .childOption(ChannelOption.SO_KEEPALIVE, true);

        System.out.println("Server is started");
        // 7.
        ChannelFuture f = serverBootstrap.bind(port).sync();

        // 8.
        f.channel().closeFuture().sync();
    }finally {
        // 9.
        workerGroup.shutdownGracefully();
        bossGroup.shutdownGracefully();
    }

}

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

    // 利用vm参数传递端口号，不传则默认8081
    int port;
    if (args.length > 0) {
        port = Integer.parseInt(args[0]);
    }else{
        port = 8081;
    }

    // 启动server
    System.out.println("Server to starting... the port is: " + port);
    new Server(port).start();
}
}

---

启动分析

1. NioEventLoopGroup

• UML类图结构

NioEventLoopGroup.png

我们跟踪的构造函数，该类提供了多个重载的构造函数，最后的一个构造函数会调用super(...)的构造函数

这里直接看其抽象父类类

public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {

    private static final int DEFAULT_EVENT_LOOP_THREADS;

    static {
        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
            "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));

        if (logger.isDebugEnabled()) {
            logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
        }
    }

protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

这里简单介绍一下该类有一个私有的静态常量 DEFAULT_EVENT_LOOP_THREADS，还有一个static静态块用于初始化该常量值，即（在不指定系统参数io.netty.eventLoopThreads的情况下）

当构造函数的参数nThreads值为0时就会取该常量值作为该EventLoop事件循环的线程数

继续往下由调用了其抽象父类的构造方法

/**
 * Create a new instance.
 *
 * @param nThreads          the number of threads that will be used by this instance.
 * @param executor          the Executor to use, or {@code null} if the default should be used.
 * @param args              arguments which will passed to each {@link #newChild(Executor, Object...)} call
 */
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
    this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}

接下来重点分析该类的this(...)函数

    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属性
    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            // 调用newChild() 方法初始化每一个children数组的元素
            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