Netty IO事件与任务处理

概述

Netty的IO事件分别为读事件（OP_READ）、写事件（OP_WRITE）、接收事件（OP_ACCEPT）、连接事件（OP_CONNECT）。其中读、写事件可以发生在客户端与服务端。接收事件只发生在服务端，服务端启动后会注册接收事件监听客户端连接。连接事件只发生在客户端，客户端启动时会连接服务端。Netty任务分为普通任务（通过execute(Runnable task) 执行）与定时任务（通过schedule(Runnable task,long delay,TimeUnit unit)执行）。无论是IO事件还是任务，都是通过NioEventLoop中对应的线程来进行处理。

NioEventLoop创建过程

在实例化NioEventLoopGroup时，默认会创建2倍CPU核心数的NioEventLoop。对于bossGroup来说，虽然会创建这么多NioEventLoop，但是如果只绑定一个端口进行事件监听，实际上只会用到一个NioEventLoop，也就是说只有一个线程在循环处理事件与任务。

EventLoopGroup bossGroup = new NioEventLoopGroup();

NioEventLoopGroup UML图：

NioEventLoopGroup无参构造方法最终会调到下面的构造方法：

public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                         final SelectStrategyFactory selectStrategyFactory) {
    /**
     * nThreads：创建线程的数量，如果不传，后续会默认为2倍CPU核心数
     * executor：默认为null，在NioEventLoopGroup父类中会进行初始化
     * selectorProvider：用于创建Java NIO的Selector对象
     * selectStrategyFactory：IO多路复用器策略工厂，值为DefaultSelectStrategyFactory
     * RejectedExecutionHandlers.reject()：拒绝策略，当线程池任务队列满了后在往其中添加任务会触发该拒绝策略
     */
    super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
}

NioEventLoopGroup构造方法中会调用其父类MultithreadEventLoopGroup的构造方法，该构造方法会初始化默认的线程数量，常量DEFAULT_EVENT_LOOP_THREADS值为2倍CPU核心数：

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

MultithreadEventLoopGroup构造方法中会调用其父类MultithreadEventExecutorGroup的构造方法，该构造方法会初始化线程执行选择器工厂，常量DefaultEventExecutorChooserFactory.INSTANCE值为EventExecutorChooserFactory：

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
    this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}

最终会调用MultithreadEventExecutorGroup如下构造方法，在该方法中会循环创建NioEventLoop：

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    
    if (executor == null) {
        // 创建线程执行器
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }
        // 创建EventExecutor数组，用来保存NioEventLoop
    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i ++) {
        // ...
        // 创建NioEventLoop
        children[i] = newChild(executor, args);
        // ...
    }
        // 创建线程选择器
    chooser = chooserFactory.newChooser(children);
        // ...
}

创建线程执行器

线程执行器ThreadPerTaskExecutor#execute方法内部使用ThreadFactory来创建并启动线程，其中ThreadFactory就是调用其构造方法传入的DefaultThreadFactory，DefaultThreadFactory#newThread方法会创建线程，并设置线程属性，如线程名称等：

public final class ThreadPerTaskExecutor implements Executor {
    private final ThreadFactory threadFactory;

    public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
        if (threadFactory == null) {
            throw new NullPointerException("threadFactory");
        }
        this.threadFactory = threadFactory;
    }

    @Override
    public void execute(Runnable command) {
        // 使用线程工厂创建并启动线程
        threadFactory.newThread(command).start();
    }
}

创建NioEventLoop

调用NioEventLoopGroup#newChild方法进行NioEventLoop的创建：

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

方法内部会调用NioEventLoop的构造方法进行创建：

NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
             SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler) {
    // 调用父类构造方法，创建任务队列以及初始化父类属性
    super(parent, executor, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
    if (selectorProvider == null) {
        throw new NullPointerException("selectorProvider");
    }
    if (strategy == null) {
        throw new NullPointerException("selectStrategy");
    }
    provider = selectorProvider;
    // 创建IO多路复用器
    selector = openSelector();
    selectStrategy = strategy;
}

该构造方法中有两个比较重要的操作：一是调用父类构造方法创建任务队列等，二是调用openSelector方法创建IO多路复用器，我们先看openSelector方法：

private Selector openSelector() {
    final Selector selector;
    try {
        // 创建Java Nio的Selector对象
        selector = provider.openSelector();
    } catch (IOException e) {
        throw new ChannelException("failed to open a new selector", e);
    }
        // 是否禁用对Java Selector的优化，如果禁用则标识不优化直接返回Java的Selector，默认为false
    if (DISABLE_KEYSET_OPTIMIZATION) {
        return selector;
    }
        // 创建SelectedSelectionKeySet，底层是数组实现，用于替换Java Selector底层selectedKeys的数据结构
    final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();
        // 通过反射获取到Selector的实现类
    Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction