Netty 源码阅读 —— 服务端创建

之前项目中用过netty，这次趁着面试空闲时间，重新梳理一遍netty源码，从服务端创建开始，话不多说，直接上代码

先看看netty服务端创建的整体代码，大概如下所示：

public void bind(int port) throws Exception {
    EventLoopGroup workGroup = new NioEventLoopGroup();
    EventLoopGroup bossGroup = new NioEventLoopGroup();

    try {
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup,workGroup).channel(NioServerSocketChannel.class)
            .option(ChannelOption.SO_BACKLOG,24)
            .childHandler(new ChildChannelHandler());
        ChannelFuture f = b.bind(port).sync();
        f.channel().closeFuture().sync();
    } finally {
        bossGroup.shutdownGracefully();
        workGroup.shutdownGracefully();
    }
}

private class ChildChannelHandler extends ChannelInitializer {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        System.out.println("server initChannel..");
        socketChannel.pipeline().addLast(new ServerHandler());
    }
}

ok ， 我们先来看看new NioEventLoopGroup() 的过程中发生了什么：

public NioEventLoopGroup() {
    this(0);
}

public NioEventLoopGroup(int nThreads) {
    this(nThreads, (ThreadFactory)null);}

public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory) {
    this(nThreads, threadFactory, SelectorProvider.provider());
}

public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory, SelectorProvider selectorProvider) {
    super(nThreads, threadFactory, new Object[]{selectorProvider});
}

可以看到首先通过层层调用后 最终调用了这一个方法，其实最后是调用了父类的构造方法，传入了三个参数，第一个是线程数，第二个 threadFactory 为空，第三个是一个SelectorProvider，顾名思义其实就是一个Selector提供类，我们可以看一下这个类的源码，果然不出所料，如果看到这里你还不熟悉的话，建议先去看看java NIO 的知识。

super(nThreads, threadFactory, new Object[]{selectorProvider})；

public static SelectorProvider provider() {
    synchronized (lock) {
        if (provider != null)
            return provider;
        return AccessController.doPrivileged(
            new PrivilegedAction() {
                public SelectorProvider run() {
                        if (loadProviderFromProperty())
                            return provider;
                        if (loadProviderAsService())
                            return provider;
                        provider = sun.nio.ch.DefaultSelectorProvider.create();
                        return provider;
                    }
                });
    }
}


public abstract AbstractSelector openSelector()
        throws IOException;


public abstract ServerSocketChannel openServerSocketChannel()
        throws IOException;


    
public abstract SocketChannel openSocketChannel()
        throws IOException;

ok，刚刚说到通过super 关键字调用父类的构造方法，NioEventLoopGroup 父类是 MultithreadEventLoopGroup ，那我们来看看父类构造方法的实现

private static final int DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt("io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() * 2));

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

发现MultithreadEventLoopGroup这个类又调用了它父类的构造方法，ok，层层往上找 ，找到MultithreadEventLoopGroup 的父类 MultithreadEventExecutorGroup，构造方法如下：

protected MultithreadEventExecutorGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    }

    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;
        } 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) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }
    }

    final FutureListener