Netty理论三：Netty线程模型

1、Reactor模式：NIO网络框架的典型模式

Reactor是网络编程中的一种设计模式，reactor会解耦并发请求的服务并分发给对应的事件处理器来处理。目前，许多流行的开源框架都用到了reactor模式，如：netty、node.js、Cindy等，包括java的nio。

何为Reactor线程模型？

Reactor模式是事件驱动的，有一个或多个并发输入源，有一个Service Handler，有多个Request Handlers；这个Service Handler会同步的将输入的请求（Event）多路复用的分发给相应的Request Handler

image.png

Reactor模式的三种形式
1、Reactor 单线程模式：

image.png

这种实现方式，和第一章java NIO中单线程NIO实现是一样的，一个Reactor处理所有的事情。

image.png

2、Reactor 多线程模式：
编解码及业务处理使用线程池，这样的话，可以避免IO阻塞（IO阻塞的代价是非常大的）。

image.png

image.png

3、Reactors 主从模式：
把Reactor分为两个，一个负责接收，一个负责读写，业务处理可以用线程池，在服务端启动时配置（也可以选择不用线程池，这个看具体业务需求）

image.png

image.png

2、Netty中如何使用Reactor模式

• 单线程Reactor 模式

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
ServerBootstrap serverBootstrap = new ServerBootstrap().group(bossGroup ,bossGroup )

• 多线程 Reactor 模式

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap serverBootstrap = new ServerBootstrap().group(bossGroup ,workerGroup )
//Handler使用线程池进行处理

• 主从Reactors 模式（官方推荐）

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap serverBootstrap = new ServerBootstrap().group(bossGroup ,workerGroup )

EventLoopGroup初始化是创建创建两个NioEventLoopGroup类型的Reactor线程池bossGroup和workGroup分别用来处理客户端的连接请求（bossGroup）和通道IO事件（workerGroup）；
注：new NioEventLoopGroup()默认创建cpu核数*2的线程数

主从模式的好处有：
1、业务解耦：一个reactor用来处理客户端连接，一个reactor用来处理业务
2、安全性：业务解耦以后，就可以在bossGroup中做一些SSL校验、ip黑名单、登录之类的安全性校验
3、性能提升：只有通过安全性校验的客户端才能继续进行业务处理，这样也能提升处理性能，否则大量的无效客户端接入和正常的业务处理混杂在一起，影响业务处理性能。
使用demo：

serverBootstrap.group(boss,worker).handler(new RuleBasedIpFilter()).childHandler(new NettyServerInitializer(this.factoryCode));

3、Netty EventLoop源码解析

1、NioEventLoopGroup整体结构

image.png

EventExecutorGroup视图

image.png

new NioEventLoopGroup源码

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 = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }
        //EventExecutorGroup里面有一个EventExecutor数组，保存了多个EventExecutor;
        children = new EventExecutor[nThreads];

        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                //初始化EventExecutor数组，数组是NioEventLoop，见下面
                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) {
                    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) {
                            // Let the caller handle the interruption.
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }
        }

        //EventExecutorChooser.next()定义选择EventExecutor的策略；
        chooser = chooserFactory.newChooser(children);

        final FutureListener