Netty之EventLoop和EventLoopGroup

https://blog.csdn.net/twt936457991/article/details/89854851
https://www.cnblogs.com/lovezmc/p/11547912.html

1.Netty线程模型

Netty线程模型并不是一成不变的，它实际取决于用户的启动参数配置。通过设置不同的启动参数，Netty可以同时支持Reactor单线程模型、多线程模型和主从Reactor多线程模型。

可以通过下图Netty服务端启动代码来了解它的线程模型

服务端启动的时候，创建了两个NioEventLoopGroup，它们实际上是两个独立的Reactor线程池。一个用于接收客户端的TCP连接，另一个用于处理I/O相关的读写操作，或者执行系统Task、定时任务Task等。
Netty用于接收客户端请求的线程池职责如下：

• 接收客户端TCP连接，初始化Channel参数；
• 将链路状态变更事件通知给ChannelPipeline；

Netty处理I/O操作的Reactor线程池职责如下：

• 异步读取通信对端的数据报，发送读事件到ChannelPipeline；
• 异步发送消息到通信对端，调用ChannelPipeline的消息发送接口；
• 执行系统调用Task；
• 执行定时任务Task，例如链路空闲状态监测定时任务。

通过调整线程池的线程个数、是否共享线程池等方式，Netty的Reactor线程模型可以在单线程、多线程和主从多线程间切换，这种灵活的配置方式可以最大程度的满足不同用户的个性化定制。
为了尽可能提升性能，Netty在很多地方进行了无锁化的设计，例如在I/O线程内部进行串行操作，避免多线程竞争导致的性能下降问题。表面上看，串行化设计似乎CPU利用率不高，并发程度不够。但是，通过调整NIO线程池的线程参数，可以同时启动多个串行化的线程并行运行，这种局部无锁化的串行线程设计相比一个队列—多个工作线程的模型性能更优。
它的设计原理如图：

Netty的NioEventLoop读取到消息之后，直接调用ChannelPipeline的fireChannelRead(Object msg)。只要用户不主动切换线程，一直都是由NioEventLoop调用用户的Handler，期间不进行线程切换。这种串行化处理方式避免了多线程操作导致的锁的竞争，从性能角度看是最优的。

1.1Netty的多线程编程最佳实践
（1）创建两个NioEventLoopGroup，用于逻辑隔离NIOAcceptor和NIOI/O线程。
（2）尽量不要在ChannelHandler中启动用户线程（解码后用于将POJO消息派发到后端业务线程的除外）。
（3）解码要放在NIO线程调用的解码Handler中进行，不要切换到用户线程中完成消息的解码。
（4）如果业务逻辑操作非常简单，没有复杂的业务逻辑计算，没有可能
可能会导致线程被阻塞的磁盘操作、数据库操作、网路操作等，可以直接在NIO线程上完成业务逻辑编排，不需要切换到用户线程。
（5）如果业务逻辑处理复杂，不要在NIO线程上完成，建议将解码后的POJO消息封装成Task，派发到业务线程池中由业务线程执行，以保证NIO线程尽快被释放，处理其他的I/O操作。
推荐的线程数量计算公式有以下两种：

• 公式一：线程数量=（线程总时间/瓶颈资源时间）*瓶颈资源的线程并行数；
• 公式二：QPS=1000/线程总时间*线程数；

由于用户场景的不同，对于一些复杂的系统，实际上很难计算出最优线程配置，指南根据测试数据和用户场景，结合公式给出一个相对合理的范围，然后对范围内的数据进行性能测试，选择相对最优值。

2.NioEventLoop源码分析

2.1 NioEventLoop设计原理
Netty的NioEventLoop并不是一个纯粹的I/O线程，它除了负责I/O的读写之外，还兼顾处理以下两类任务：

• 系统Task：通过调用NioEventLoop的execute(Runnable task)方法实现，Netty有很多系统Task，创建它们的主要原因是：当I/O线程和用户线程同时操作网络资源时，为了防止并发操作导致的锁竞争，将用户线程的操作封装成Task放入消息队列中，由I/O线程负责执行，这样就实现了局部无锁化；
• 定时任务：通过调用NioEventLoop的schedule(Runnable command,long delay,TimeUnit unit)方法实现。

2.2NioEventLoop继承关系类图

2.3 NioEventLoop
作为NIO框架的Reactor线程，NioEventLoop需要处理网络I/O线程读写事件，因此它必须聚合一个多路复用器对象。它的Selector定义如下

Selector初始化非常简单，直接调用Selector.open()方法九年创建并打开一个新的Selector。Netty对Selector的selectedKeys进行了优化，用户可以通过io.netty.noKeySet Optimization开关决定是否启用该优化项。默认不打卡selectedKeys优化功能。
Selector初始化如下

 private SelectorTuple openSelector() {
   
        final Selector unwrappedSelector;
        try {
   
            unwrappedSelector = provider.openSelector();
        } catch (IOException e) {
   
            throw new ChannelException("failed to open a new selector", e);
        }

        if (DISABLE_KEY_SET_OPTIMIZATION) {
   
            return new SelectorTuple(unwrappedSelector);
        }

        Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction<Object>() {
   
            @Override
            public Object run() {
   
                try {
   
                    return Class.forName(
                            "sun.nio.ch.SelectorImpl",
                            false,
                            PlatformDependent.getSystemClassLoader());
                } catch (Throwable cause) {
   
                    return cause;
                }
            }
        });

        if (!(maybeSelectorImplClass instanceof Class) ||
            // ensure the current selector implementation is what we can instrument.
            !((Class<?>) maybeSelectorImplClass).isAssignableFrom(unwrappedSelector.getClass())) {
   
            if (maybeSelectorImplClass instanceof Throwable) {
   
                Throwable t = (Throwable) maybeSelectorImplClass;
                logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, t);
            }
            return new SelectorTuple(unwrappedSelector);
        }

        final Class<?> selectorImplClass = (Class<?>) maybeSelectorImplClass;
        final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();

        Object maybeException = AccessController.doPrivileged(new PrivilegedAction<Object>() {
   
            @Override
            public Object run() {
   
                try {
   
                    Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
                    Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");

                    if (PlatformDependent.javaVersion() >= 9 && PlatformDependent.hasUnsafe()) {
   
                        // Let us try to use sun.misc.Unsafe to replace the SelectionKeySet.
                        // This allows us to also do this in Java9+ without any extra flags.
                        long selectedKeysFieldOffset = PlatformDependent.objectFieldOffset(selectedKeysField);
                        long publicSelectedKeysFieldOffset =
                                PlatformDependent.objectFieldOffset(publicSelectedKeysField);

                        if (selectedKeysFieldOffset != -1 && publicSelectedKeysFieldOffset != -1) {
   
                            PlatformDependent.putObject(
                                    unwrappedSelector, selectedKeysFieldOffset, selectedKeySet);
                            PlatformDependent.putObject(
                                    unwrappedSelector, publicSelectedKeysFieldOffset, selectedKeySet);
                            return null;
                        }
                        // We could not retrieve the offset, lets try reflection as last-resort.
                    }

                    Throwable cause = ReflectionUtil.trySetAccessible(selectedKeysField, true);
                    if (cause != null) {