Netty服务端启动

一、Netty4服务端启动代码

    private static final EventLoopGroup bossGroup = new NioEventLoopGroup();
    private static final EventLoopGroup workerGroup = new NioEventLoopGroup();
    protected static void run() throws Exception {
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup);
        b.channel(NioServerSocketChannel.class);
        b.childHandler(new ChannelInitializer() {
            @Override
            public void initChannel(SocketChannel ch) throws Exception {
                ChannelPipeline pipeline = ch.pipeline();
                pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));
                pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));
                pipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
                pipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
                pipeline.addLast(new TcpServerHandler());
            }
        });
        b.bind("127.0.0.1", 9999).sync();
    }

二、具体解析

1.初始化线程池new NioEventLoopGroup()，设置线程数，选择器提供者，线程池选择策略，任务队列拒绝策略

public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory,
        final SelectorProvider selectorProvider, final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, threadFactory, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
    }

MultithreadEventLoopGroup-》MultithreadEventExecutorGroup，省略了一些优雅关闭的钩子监听器

protected MultithreadEventExecutorGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
        if (threadFactory == null) {
            threadFactory = newDefaultThreadFactory();
        }
        children = new SingleThreadEventExecutor[nThreads];
        if (isPowerOfTwo(children.length)) {
            chooser = new PowerOfTwoEventExecutorChooser();
        } else {
            chooser = new GenericEventExecutorChooser();
        }
        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                children[i] = newChild(threadFactory, args);
                success = true;
            }
        }
    }

初始化线程选择器，这里会根据是否是2的幂次来进行位运算的优化，创建线程newChild，子类NioEventLoopGroup中

 protected EventExecutor newChild(ThreadFactory threadFactory, Object... args) throws Exception {
        return new NioEventLoop(this, threadFactory, (SelectorProvider) args[0],
            ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);
    }

保存选择提供者并且生成Selector，用参数DISABLE_KEYSET_OPTIMIZATION决定是否开启selectedKeys优化

NioEventLoop(NioEventLoopGroup parent, ThreadFactory threadFactory, SelectorProvider selectorProvider,
                 SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler) {
        super(parent, threadFactory, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
        provider = selectorProvider;
        selector = openSelector();
        selectStrategy = strategy;
    }

SingleThreadEventLoop-》SingleThreadEventExecutor，省略了优雅关闭等收尾代码，设置最大待处理任务队列LinkedBlockingQueue，一个线程thread 就创建完成。放入EventExecutor[] children保存起来。

protected SingleThreadEventExecutor(
            EventExecutorGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp, int maxPendingTasks,
            RejectedExecutionHandler rejectedHandler) {
        this.parent = parent;
        this.addTaskWakesUp = addTaskWakesUp;

        thread = threadFactory.newThread(new Runnable() {
            @Override
            public void run() {
                boolean success = false;
                updateLastExecutionTime();
                try {
                    SingleThreadEventExecutor.this.run();
                    success = true;
                } 
            }
        });
        threadProperties = new DefaultThreadProperties(thread);
        this.maxPendingTasks = Math.max(16, maxPendingTasks);
        taskQueue = newTaskQueue();
        rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
    }

2.初始化ServerBootstrap ，b.group(bossGroup, workerGroup)设置两个线程池，bossGroup监听本地绑定端口，接收客户端连接请求，然后在workerGroup给这个客户端Channel分配一个线程进行后续处理，一般情况下客户端不是很多时这个通常可以设置成1，NioEventLoopGroup默认值是处理器核心数的两倍，第二个具体处理与客户端的I/O读写请求以及一些服务端的任务。设置AbstractBootstrap属性group为bossGroup，ServerBootstrap属性childGroup为workerGroup，b.channel(NioServerSocketChannel.class)设置服务端通讯方式（nio，oio，epoll），AbstractBootstrap属性channelFactory为new BootstrapChannelFactory(channelClass)，后面会进行初始化，b.childHandler(new ChannelInitializer() {});，设置与客户端通信通道的处理器childHandler。

3.绑定ip端口b.bind("127.0.0.1", 9999).sync();AbstractBootstrap绑定ip端口，初始化注册通道等等处理，如果同步没执行完成，设置监听器进行异步处理

private ChannelFuture doBind(final SocketAddress localAddress) {
        final ChannelFuture regFuture = initAndRegister();
        final Channel channel = regFuture.channel();
        if (regFuture.cause() != null) {
            return regFuture;
        }
        if (regFuture.isDone()) {
            // At this point we know that the registration was complete and successful.
            ChannelPromise promise = channel.newPromise();
            doBind0(regFuture, channel, localAddress, promise);
            return promise;
        } else {
            // Registration future is almost always fulfilled already, but just in case it's not.
            final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
            regFuture.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    Throwable cause = future.cause();
                    if (cause != null) {
                        // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
                        // IllegalStateException once we try to access the EventLoop of the Channel.
                        promise.setFailure(cause);
                    } else {
                        // Registration was successful, so set the correct executor to use.
                        // See https://github.com/netty/netty/issues/2586
                        promise.executor = channel.eventLoop();

                        doBind0(regFuture, channel, localAddress, promise);
                    }
                }
            });
            return promise;
        }
    }

4.创建NioServerSocketChannel实例

final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            channel = channelFactory().newChannel();
            init(channel);
        } 
        ChannelFuture regFuture = group().register(channel);
        return regFuture;
    }

private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();
    private static ServerSocketChannel newSocket(SelectorProvider provider) {
        try {
            return provider.openServerSocketChannel();
        }
    }
    private final ServerSocketChannelConfig config;
    public NioServerSocketChannel() {
        this(newSocket(DEFAULT_SELECTOR_PROVIDER));
    }
    public NioServerSocketChannel(ServerSocketChannel channel) {
        super(null, channel, SelectionKey.OP_ACCEPT);
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());
    }

AbstractNioMessageChannel-》AbstractNioChannel，设置SelectableChannel，设置监听事件SelectionKey.OP_ACCEPT，非阻塞

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
        super(parent);
        this.ch = ch;
        this.readInterestOp = readInterestOp;
        try {
            ch.configureBlocking(false);
        } 
    }

AbstractChannel， 初始化NioMessageUnsafe用来处理网络数据交互，

 protected AbstractChannel(Channel parent) {
        this.parent = parent;
        unsafe = newUnsafe();
        pipeline = newChannelPipeline();
    }

创建通道DefaultChannelPipeline，tail 和head 是管道两边的处理器，后续另外增加处理器都在这两个中间，类似链表形式

 protected DefaultChannelPipeline(Channel channel) {
        this.channel = ObjectUtil.checkNotNull(channel, "channel");
        tail = new TailContext(this);
        head = new HeadContext(this);
        head.next = tail;
        tail.prev = head;
    }

5. NioServerSocketChannel初始化并且设置网络属性init(channel);在ServerBootstrap中，设置Channel通道选项属性，给DefaultChannelPipeline管道增加处理器，里面是回调加异步，ServerBootstrapAcceptor处理器主要的功能是处理客户端连接请求，然后给客户端从childGroup中取出一个线程专门处理Channel请求。

void init(Channel channel) throws Exception {
        final Map, Object> options = options();
        synchronized (options) {
            setChannelOptions(channel, options, logger);
        }

        final Map, Object> attrs = attrs();
        synchronized (attrs) {
            for (Entry, Object> e: attrs.entrySet()) {
                @SuppressWarnings("unchecked")
                AttributeKey