NIO 服务端 ServerSocketChannel 启动步骤

1. 创建

• 创建 serverSocketChannel，并将其绑定到某个端口，配置为非阻塞。
• 创建 selector。

2. 注册

• 将 ServerSocketChannel 注册到 selector，并监听 accept 事件。

3. 等待连接

• 调用 selector.select() 方法阻塞，直到有客户端连接。

4. 处理 accept 事件

• 从 selector.selectedKeys() 方法获取客户端连接的 socketChannel，对其进行操作。

Netty 是对 Java NIO 的封装处理，使NIO更容易被使用，但是不管怎么封装，底层也需要遵循这个步骤来启动服务端

Reactor 模式

Doug Lea 在 《Scalable IO in Java》 中定义了三种 Reactor 模式，分别为

1. Basic Reactor
2. Multithreaded Reactor
3. Multiple Reactors

Basic Reactor

Basic Reactor 如下图所示：

Basic Reactor.png

特点：

• 在 Basic Reactor 中，不管是处理 serverSocketChannel 的 accept 事件 还是处理 socketChannel 的 read/write 等事件，都是在同一个线程中进行的

缺点：

• 资源利用率低，一个线程处理所有的请求，无法有效利用CPU

Multithreaded Reactor

Multithreaded Reactor 如下图所示：

Multithreaded Reactor.png

特点：

• 当 selector 返回 serverSocketChannel 的 accept 事件后，由 main 线程处理该事件
• 当 selector 返回 socketChannel 的 read/write 事件后，将该事件让 ThreadPool 分配的线程来处理

优点：

• 将 accept 事件和 read/write 事件分开处理，有效利用CPU资源

缺点：

• 一个 selector 轮询所有事件，当需要处理很多socketChannel 的 read/write 事件时，部分 serverSocketChannel 的 accept 会阻塞，未能有效处理客户端的连接请求

Multiple Reactors

Multiple Reactors 如下图所示：

Multiple Reactors.png

特点：

1. 有两个 seletcor，main selector 和 sub selector
2. 将 serverSocketChannel 注册到 main selector 中，并让 main selctor
   监听 accept 事件，当返回 accept 事件时，使用 main 线程进行处理
3. 将 socketChannle 注册到 sub selector 中，让 sub selector 监听 read/write 等事件，当返回 read/write事件时，将事件给 ThreadPool 分配的线程处理

优点：

1. 当 server 与很多 client 进行读写操作时，并不会阻塞 main selector的 accept 事件处理，使accept 事件能够得到及时处理

Netty 对 Reactor 模式的支持

Netty 对三种 Reactor 模式都能进行处理，只需要对 ServeBootstrap 分配不同配置的 NioEventLoopGroup即可

Netty 对 Basic Reactor 的支持

EventLoopGroup group = new NioEventLoopGroup(1);

ServerBootstrap b = new ServerBootstrap();
           b.group(group)
           ...

• NioEventLoopGroup 其实是 NioEventLoop 的线程集合，在 NioEventLoopGroup 是包含1个或者多个NioEventLoop 的线程池。
• 而在每个 NioEventLoop 中间，包含着一个 seletor，用来监听 Channel 的事件。
• 在上面代码中，NioEventLoopGroup 的构造参数表示NioEventLoop线程集合的数量，在这里只分配一个 NioEventLoop，所以就只有一个selector，将所有的Channel 都将注册到 selector 中，NioEventLoopGroup分配了一个NioEventLoop，则说明只有一个NioEventLoopGroup的线程组里面只有一个线程，对于所有的channel都由这个线程进行处理，故满足了 Basic Reactor 的特性。

Netty 对 Multithreaded Reactor 的支持

• Netty 并没有对 Multithreaded Reactor 的支持

• 因为在 Netty 中，每个 NioEventLoop 都有一个 selector，SocketChannel/ServerSocketChannel 会被注册到某一个 NioEventLoop 里面的selector中，当这个selector 返回事件时，也只会被该 NioEventLoop 所在的线程进行处理。

• 而 NioEventLoopGroup 是 NioEventLoop的集合

• 所以如果为 NioEventLoopGroup 集合里有多个 NioEventLoop，则也会创建多个selector，每个 NioEventLoop 都会创建一个线程去处理selector 的事件，做不到一个 selector 监听的事件交给多个线程去处理。

在有些文章中说，以下代码就是实现了Multithreaded Reactor

EventLoopGroup group = new NioEventLoopGroup();

ServerBootstrap b = new ServerBootstrap();
           b.group(group)
           ...

但是进去 ServerBootstrap 源码发现，其实只不过是将 group 集合中抽一个 NioEventLoop 作为 Main Reactor，group 集合里面的其他NioEventLoop 则继续作为 Sub Reactor，是 Netty 对 Multiple Reactors 的支持。

    @Override
    public ServerBootstrap group(EventLoopGroup group) {
        // 此方法也是 bossGroup, workerGroup 调用的方法
        return group(group, group);
    }

    public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
        super.group(parentGroup);
        if (this.childGroup != null) {
            throw new IllegalStateException("childGroup set already");
        }
        this.childGroup = ObjectUtil.checkNotNull(childGroup, "childGroup");
        return this;
    }

Netty 对 Multiple Reactors 的支持

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup wokerGroup = new NioEventLoopGroup();

ServerBootstrap b = new ServerBootstrap();
           b.group(bossGroup, wokerGroup )
           ...

• bossGroup 作为 Main Reactor，serverSocketChannel 将注册accept事件到 bossGroup 里面的 NioEventLoop 中 selector 中，由该 selector 轮训 accept 事件。
• workerGroup 作为 Sub Reactor，所有的 socketChannel 会被注册到workerGroup 里的 NioEventLoop 中 selector,这些 selector 负责轮训 read 事件，监听到的事件交给对应的NioEventLoop 进行处理。

Reactor 和 Selector：
在阅读 Netty 源码之前，一直以为 Reactor 就是 Selector，Multi Reactor （主从Reactor）就是一个 selector 负责监听 accept 事件，一个 selector 负责监听 read 事件，只不过处理 accept 事件的线程只有一个，而处理 read 事件的线程有多个。
但是看了 Netty 源码后发现并不是这样，Reactor 其实是 selector 的线程集合，一个 Reactor 可以有一个或者多个 selector，在 Netty 中，Main Reactor 只有一个 selector， 而 Sub Reactor 有多个 selector，每个 selector 互不影响，都只处理在自己中注册的socketChannel