Netty服务器源码分析

本文基于Netty 4

在讨论Netty服务器启动之前，先回顾一下服务端使用Java nio selector的启动过程：

//1. 获取服务端通道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
//2. 绑定端口
ssChannel.bind(new InetSocketAddress(9898));
//3. 设置为非阻塞模式
ssChannel.configureBlocking(false);

Selector selector = Selector.open();
//4. 向监听器注册accept事件
ssChannel.register(selector, SelectionKey.OP_ACCEPT);

while (selector.select() > 0) {
    //5. 获取监听器上所有的监听事件值
    Iterator it = selector.selectedKeys().iterator();
    while (it.hasNext()) {
        SelectionKey key = it.next();
        if (key.isAcceptable()) {            
            ServerSocketChannel server = (ServerSocketChannel)key.channel();
            SocketChannel socketChannel = server.accept();
            socketChannel.configureBlocking(false);
            //注册read事件
            socketChannel.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            SocketChannel channel = (SocketChannel) key.channel();
            readMsg(channel);
        } else if(...) {
            ...
        }
        it.remove();
    }
}

Netty nio模式的启动过程：

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
    ServerBootstrap b = new ServerBootstrap();
    b.group(bossGroup, workerGroup);
    b.channel(NioServerSocketChannel.class);
    b.option(ChannelOption.SO_BACKLOG, 128);
    b.childOption(ChannelOption.SO_REUSEADDR, true);
    b.childOption(ChannelOption.TCP_NODELAY, true);
    b.childOption(ChannelOption.SO_KEEPALIVE, true);
    b.childHandler(new ChannelInitializer() {
        @Override
        public void initChannel(SocketChannel ch) throws Exception {
            ChannelPipeline pipeline = ch.pipeline();
            pipeline.addLast("http-decoder", new HttpRequestDecoder());
            pipeline.addLast("aggregator", new HttpObjectAggregator(1048576));
            pipeline.addLast("encoder", new HttpResponseEncoder());
            pipeline.addLast(new MyInboundHandler());
        }
    });

    ChannelFuture f = b.bind(8080).sync();
    f.channel().closeFuture().sync();
} finally {
    workerGroup.shutdownGracefully();
    bossGroup.shutdownGracefully();
}

其实，无论是Java nio，还是Netty nio，总体都包含两个方面：1. 线程模型；2. IO模型；下面先分析Netty的线程模型。

Netty线程启动

NioEventLoopGroup是Netty线程的核心，下面看一下这个类的初始化
NioEventLoopGroup # 构造方法

public NioEventLoopGroup() {
      this(0);
}
//无参的构造转调到了这里
public NioEventLoopGroup(int nThreads) {
     //这里的Executor传入了null
     this(nThreads, (Executor) null);
}

上面的构造方法最终会调用父类的构造方法
MultithreadEventLoopGroup # 构造方法

protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
     //这里若threads==0，会初始化一个值；
    //该初始值的算法 Math.max(1, SystemPropertyUtil.getInt("io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() * 2))
     super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

最终走到这里 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设为了null，这里会赋一个值，这个executor的作用是创建新 Thread并运行任务；后面会发现它的作用
     executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
 }

 //这里会根据threads的值创建若干个EventExecutor
 children = new EventExecutor[nThreads];

 for (int i = 0; i < nThreads; i ++) {
     boolean success = false;
     try {
         //往里看一下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) {
              .........
         }
     }
 }
 //初始了chooser，后面会使用该chooser选择一个EventLoop
 chooser = chooserFactory.newChooser(children);

 final FutureListener