Netty源码剖析（NioEventLoopGroup创建流程）

朱雀 2022-10-04 14:55 174阅读 0赞

> 原创不易，转载请注明出处  
> 本文基于netty版本4.1.33.Final

### 文章目录 ###

*   *   *  前言
         *  1. NioEventLoopGroup与NioEventLoop
         *  2.NioEventLoopGroup初始化源码分析
         *  3.NioEventLoop初始化源码分析
         *  总结

--------------------

### 前言 ###

我们在《[基于Netty实现一个服务端/客户端通信demo][Netty_demo]》一文中基于netty实现了一个nio服务端、客户端通信的demo，也算是初步玩了玩netty，体验了一下基于netty的nio网络编程，说实话我首次接触netty编程的时候很懵逼，而且在很长一段时间内都处于懵逼状态，根本记不住这些api，但是当我对java nio 编程很熟练，并且了解了netty核心运行原理的时候，我才能熟练的掌握netty网络编程api，这说明了解每一步的底层运行原理才能更好的使用。好了，本文主要分为2部分，一是简单介绍一下NioEventLoopGroup以及NioEventLoop ，二是进行源码分析，看看NioEventLoopGroup创建的时候都干了些啥

### 1. NioEventLoopGroup与NioEventLoop ###

NioEventLoopGroup 从名字上看的话，就是nio 事件循环组，NioEventLoop 从名字上看就是个nio事件循环这么个东西，很明显NioEventLoopGroup 是个组，管理着一堆的NioEventLoop，NioEventLoop 用作nio事件循环，熟悉java nio的同学应该都知道`selector.select();`这行代码，它其实就是看看有没有网络事件的发生，而NioEventLoop 核心就是干这么个事情，给他挂上个线程，跑就完事了，就是不断的看看有没有网络事件的发生。  
下面看看NioEventLoopGroup继承关系

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]  
这里稍微看下就行，继承MultithreadEventLoopGroup，多线程事件循环器组，最上面其实就是jdk Executor接口，看到Executor这个东西就能想起来线程池了吧，这里你可以把 NioEventLoopGroup 理解成线程组，里面维护了一堆的NioEventLoop ，然后每个NioEventLoop 就是个线程，每个NioEventLoop 有个selector，不断的轮询着，看看有没有网络事件的发生，NioEventLoopGroup 管理着NioEventLoop 的生命周期，管着NioEventLoop 创建关闭，同时提供了next 方法获取一个NioEventLoop 。  
再来看看 NioEventLoop 继承关系类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70 1]  
这个就比较复杂了，继承SingleThreadEventLoop ，单线程事件循环器，知道它是个线程就行了，然后不断轮询，看看有没有事件的发生。

### 2.NioEventLoopGroup初始化源码分析 ###

接下来，我们就看看NioEventLoopGroup 实例化都干了些什么。

EventLoopGroup bossGroup = new NioEventLoopGroup();

我们这里来个无参的。

public NioEventLoopGroup() { 
            this(0);
     }
    public NioEventLoopGroup(int nThreads) { 
            this(nThreads, (Executor) null);// executor 是空
    }
    public NioEventLoopGroup(int nThreads, Executor executor) { 
            // 多一个SelectorProvider
            this(nThreads, executor, SelectorProvider.provider());
    }

**到这里我们不得不停下，有个非常重要的点`SelectorProvider.provider()`，这个东西熟悉java nio的同学应该知道，创建Selector，ServerSocketChannel用的**，还有一个点就是我们用的无参构造，线程是0。再接着往下

public NioEventLoopGroup(
            int nThreads, Executor executor, final SelectorProvider selectorProvider) { 
        //多一个默认的策略
         this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
    }

这里又多了一个SelectStrategyFactory ，使用的是默认的，先不用管。  
public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,  
final SelectStrategyFactory selectStrategyFactory) \{

// 多一个默认拒绝策略
    super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());

\}  
这里又多了一个拒绝策略，这个也不用管，可以看到调用的父类MultithreadEventLoopGroup 的构造。

protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) { 
        /// 如果设置的线程数是0 则使用默认的线程数
        super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
    }

可以看到，判断线程数是不是0，如果是的话，就用DEFAULT\_EVENT\_LOOP\_THREADS 这个东西，如果不是的话，就用你自己指定的那个，由于我们没有指定，我们需要看下netty默认的group组线程数是多少。

// 默认EventLoop线程数
    private static final int DEFAULT_EVENT_LOOP_THREADS;
    
    static { 
    
        // 获取 系统参数io.netty.eventLoopThreads
        // 默认是cpu*2线程数
        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
                "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));
    
        if (logger.isDebugEnabled()) { 
            logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
        }
    }

静态代码块，**去系统参数io.netty.eventLoopThreads 获取线程数，如果没有的话就是cpu核心数\*2**

接着往下看，这里调用父类MultithreadEventExecutorGroup 的构造

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) { 
         // 指定EventExecutor选择器
         this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
     }

这里在原来参数基础上，又多了一个默认EventExecutor选择器工厂，其实就是创建EventExecutor选择器的工厂，不用管  
**核心来了：**

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                                EventExecutorChooserFactory chooserFactory, Object... args) { 
    
            // 验证线程 线程小于0 抛出异常
            if (nThreads <= 0) { //验证线程
                throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
            }
            // 创建执行器 如果是null的话，使用默认的
            if (executor == null) { 
                // 创建一个默认的线程工厂
                executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
            }
            // 创建 EventExecutor数组
            children = new EventExecutor[nThreads];
            // 创建 EventExecutor 对象
            for (int i = 0; i < nThreads; i ++) { 
                boolean success = false;//是否创建成功
                try { 
    
                    // 进行创建， newChild 需要子类来具体实现
                    children[i] = newChild(executor, args);//创建EventExecutor
                    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();
                        }
    
                        //确保所有的EventExecutor全部关闭
                        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;
                            }
                        }
                    }
                }
            }
            // 创建EventExecutor选择器
            chooser = chooserFactory.newChooser(children);
            ...
        }

首先是验证线程数，小于等于0的话抛出异常，executor 是null的话，就会创建一个线程工厂，ThreadPerTaskExecutor你可以理解是创建线程的。  
接着就是创建EventExecutor 数组，数组大小线程数大小，遍历调用newChild 方法 创建EventExecutor对象赋值给这个数组，newChild 方法是个抽象方法，需要子类来实现。finally 里面其实就是看看有没有失败，如果有一个失败的，就会销毁，目的就是保证全部都创建成功。  
最后调用选择器工厂创建一个选择器，这里很简单，就是判断EventExecutor 数量大小来创建，这里就不详细介绍了。

我们这里主要看下newChild 方法是怎样创建EventExecutor 的，首先要说明NioEventLoop其实就是EventExecutor 的实现类。

protected abstract EventExecutor newChild(Executor executor, Object... args) throws Exception;

这个方法需要子类实现，我们的NioEventLoopGroup就实现了，我们看看。

protected EventLoop newChild(Executor executor, Object... args) throws Exception { 
    
          // 这里就是创建 NioEventLoop 对象
          return new NioEventLoop(this,// group
                  executor,// 线程工厂
                  (SelectorProvider) args[0],//SelectorProvider
              ((SelectStrategyFactory) args[1]).newSelectStrategy(),//select 策略 ，通过工厂来获得 ，使用默认的DefaultSelectStrategy
                  (RejectedExecutionHandler) args[2]);// 拒绝策略
    
          // 创建NioEventLoop对象
      }

很简单，就是创建NioEventLoop 对象，然后返回完事。  
接下来看看NioEventLoop 的实例化过程。

### 3.NioEventLoop初始化源码分析 ###

NioEventLoop(NioEventLoopGroup parent,// group
                     Executor executor,   // 线程工厂
                     SelectorProvider selectorProvider,// SelectorProvider
                     SelectStrategy strategy, // select 策略
                     RejectedExecutionHandler rejectedExecutionHandler// 拒绝策略
        ) { 
    
            /// 先调用父类
            super(parent, executor, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
           	...
            provider = selectorProvider;
    
            // 获取Selector
            final SelectorTuple selectorTuple = openSelector();
    
    
            // 包装过的selector
            selector = selectorTuple.selector;
            // 没有包装的selector
            unwrappedSelector = selectorTuple.unwrappedSelector;
            // select 策略
            selectStrategy = strategy;
        }

其实就是两部分，一部分是调用父类搞一些事情，第二部分就是openSelector，就是执行java nio 里面的`Selector.open()`这句，不过它这里对selector进行一些优化，我们只需要知道netty对selector有优化即可。  
调用父类搞了啥我们这里就不看了，其实就是创建任务队列啥的。  
openSelector这部分我只需要知道 `unwrappedSelector = provider.openSelector();`就ok了，就是调用jdk的 api创建selector，这里要记住的是**一个NioEventLoop有一个selector**。

### 总结 ###

NioEventLoopGroup初始化最最核心的就是创建了一堆 NioEventLoop ，如果你不指定个数的话，默认netty就会创建cpu核心数\*2 个。  
NioEventLoop初始化最最核心的就是创建任务队列与 创建selector，一个NioEventLoop 持有一个自己的selector对象。

[Netty_demo]: https://inetyoung.blog.csdn.net/article/details/118676491
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]: /images/20221004/073934e69bf4411094000152129dff9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70 1]: /images/20221004/c4a86c672b564a5781a0e7a6b29b0d04.png