源码分析netty服务端运行过程

原生Java nio实现

java原生api大致实现流程如下，netty底层的实现方式很类似

// 代码块1
// 打开selector
Selector selector = Selector.open();
// 打开ServerSocketChannel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 绑定监听端口
serverSocketChannel.socket().bind(new InetSocketAddress(5002), 1024);
// 非阻塞
serverSocketChannel.configureBlocking(false);
// 注册接收事件
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
// 代码块1
for(;;) {
    int num = selector.select();
    if (num > 0) {
        // 接收客户端连接
        SocketChannel channel = serverSocketChannel.accept();
        // 代码块2
        // do something
        // 代码块2
    }
}
// 代码块1

netty服务端示例

netty通过线程组分工，大大的提高了吞吐量；示例有主、子两个线程组，主线程负责客户端的接入，相当于原生示例的代码块1；子线程负责客户端的数据交互，相当于原生示例的代码块2

static final boolean SSL = System.getProperty("ssl") != null;
static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));

public static void main(String[] args) throws Exception {
    // Configure SSL.
    final SslContext sslCtx;
    if (SSL) {
        SelfSignedCertificate ssc = new SelfSignedCertificate();
        sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
    } else {
        sslCtx = null;
    }

    // Configure the server.
    // 主线程组
    EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    // 子线程组
    EventLoopGroup workerGroup = new NioEventLoopGroup(1);
    // 子线程组线程业务出口/入口
    final EchoServerHandler serverHandler = new EchoServerHandler();
    try {
        // 服务启动装置
        ServerBootstrap b = new ServerBootstrap();
        // 绑定主/子线程组
        b.group(bossGroup, workerGroup)
        // nerry服务channel包装，相当于原生java ServerSocketChannel 
         .channel(NioServerSocketChannel.class)
         .option(ChannelOption.SO_BACKLOG, 100)
         .handler(new LoggingHandler(LogLevel.INFO))
         .childHandler(new ChannelInitializer() {
             @Override
             public void initChannel(SocketChannel ch) throws Exception {
                 ChannelPipeline p = ch.pipeline();
                 if (sslCtx != null) {
                     p.addLast(sslCtx.newHandler(ch.alloc()));
                 }
                 //p.addLast(new LoggingHandler(LogLevel.INFO));
                 p.addLast(serverHandler);
             }
         });

        // Start the server.
        ChannelFuture f = b.bind(PORT).sync();

        // Wait until the server socket is closed.
        f.channel().closeFuture().sync();
    } finally {
        // Shut down all event loops to terminate all threads.
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

线程组（NioEventLoopGroup）

比较核心代码在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;
                    }
                }
            }
        }
    }

    chooser = chooserFactory.newChooser(children);

    final FutureListener