文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

一篇学会NioEventLoopGroup源码解析

2024-12-03 02:32

关注

NioEventLoopGroup的初始化源码

一、寻找源码的过程

我们前面说到过，NioEventLoopGroup我们可以近乎把它看作是一个线程池，该线程池会执行一个一个的任务，我们常用的NioEventLoopGroup大概有两种，NioEventLoopGroup(int nThreads),NioEventLoopGroup()，即一个是指定线程数量的，一个是默认指定线程数量的!这里我们以无参构造为入口进行分析!

  1. EventLoopGroup work = new NioEventLoopGroup(); 
  1. public NioEventLoopGroup() { 
  2.     this(0); 
  3. } 

当我们使用默认的数量的时候，他会传递一个0，我们继续往下跟!

  1. public NioEventLoopGroup(int nThreads) { 
  2.     this(nThreads, (Executor) null); 
  3. } 

注意这里传递的参数是:0,null

  1. public NioEventLoopGroup(int nThreads, Executor executor) { 
  2.     //每个 group维护一个 SelectorProvider 主要用它获取selector选择器 
  3.     this(nThreads, executor, SelectorProvider.provider()); 
  4. } 

这里面多传递了一个 SelectorProvider.provider()，该方法是JDK NIO提供的API主要可以获取NIO选择器或者Channel,如下图：

我们回归主线继续跟：

  1. public NioEventLoopGroup( 
  2.             int nThreads, Executor executor, final SelectorProvider selectorProvider) { 
  3.     this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE); 
  4. } 

这里多传递了一个 DefaultSelectStrategy选择策略，这在后面讲解NioEventLoop会具体讲解，不做阐述!

  1. public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider, 
  2.                              final SelectStrategyFactory selectStrategyFactory) { 
  3.     super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject()); 
  4. } 

我们会发现这里还会默认传递一个拒绝策略RejectedExecutionHandlers.reject()，这个拒绝策略是干嘛的呢?

  1. @Override 
  2. public void rejected(Runnable task, SingleThreadEventExecutor executor) { 
  3.     throw new RejectedExecutionException(); 
  4. } 

我们得到一个结论，当某些条件触发这个拒绝策略，那么他会抛出一个RejectedExecutionException异常，具体什么时候触发，后续也会详细说明，这里只需要记住就OK了!

我们继续回到主线, 这里我们开始调用父类，还记得上一节课我们分析的NioEventLoopGroup的父类是谁吗?没错是：MultithreadEventLoopGroup, 我们会进入到MultithreadEventLoopGroup里面：

  1. protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) { 
  2.     //线程数量为0时  使用默认的cpu * 2 
  3.     super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args); 
  4. } 

nThreads还记得是几吗?是0对不对，这里有个判断，当你的线程数量为0的时候，会使用DEFAULT_EVENT_LOOP_THREADS当作线程池的数量，DEFAULT_EVENT_LOOP_THREADS是多少呢?

  1. DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt("io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2)); 

默认是CPU的两倍，所以我们现在得到一个结论，当我们使用默认的NioEventLoopGroup的时候，系统会默认使用系统CPU核数*2当作线程池的数量!

我们上一步传递过来的selectorProvider、拒绝策略、selectStrategyFactory被封装为数组，并放在args[0]，args[1], args[2]的位置!

我们继续回到主线，这里又再次调用到父类，MultithreadEventExecutorGroup:

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

注意，这里又再次多传递了一个参数：DefaultEventExecutorChooserFactory一个选择器工厂，这里会返回一个选择器，他是DefaultEventExecutorChooserFactory类型的，具体分析后面会分析!我们继续回到主线：

  1. protected MultithreadEventExecutorGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, Object... args) { 
  2.     ..........后续源码补充.......... 
  3. } 

到这里我们终于看到了一大段代码，这里是EventLoopGroup的主要逻辑，我们逐行分析：

二、构建线程执行器

1. 源码解析

  1. //newDefaultThreadFactory  构建线程工厂 
  2. if (executor == null) { 
  3.     //创建并保存线程执行器  执行器  执行任务的  默认是  DefaultThreadFactory 线程池 
  4.     executor = new ThreadPerTaskExecutor(newDefaultThreadFactory()); 
  5. } 

这里会判断我们传入的执行器是否为空，否则就新建一个，我们还记得executor是什么值吗?是null，对不对，所以它会进入到这里的逻辑我们进入到newDefaultThreadFactory源码里面看一下：

newDefaultThreadFactory()主要逻辑

  1. protected ThreadFactory newDefaultThreadFactory() { 
  2.     return new DefaultThreadFactory(getClass()); 
  3. } 

可以看到，这里向执行器里面传入了一个 DefaultThreadFactory一个默认的线程工厂!

ThreadPerTaskExecutor主要逻辑：

  1.  
  2. @Override 
  3. public void execute(Runnable command) { 
  4.     //执行任务 
  5.     threadFactory.newThread(command).start(); 
  6. } 

我们发现，这里调用了一个我们传入的线程工厂，创建了一个新的线程并调用start方法启动了起来，那么他是如何创建的呢? 我们进入到newThread源码里面查看，由于我们默认使用的线程工厂是 DefaultThreadFactory, 所以，我们会进入到 DefaultThreadFactory#newThread

  1. @Override 
  2. public Thread newThread(Runnable r) { 
  3.     //创建一个线程 每次执行任务的时候都会创建一个线程实体 
  4.     Thread t = newThread(FastThreadLocalRunnable.wrap(r), prefix + nextId.incrementAndGet()); 
  5.     try { 
  6.         if (t.isDaemon() != daemon) { 
  7.             t.setDaemon(daemon); 
  8.         } 
  9.  
  10.         if (t.getPriority() != priority) { 
  11.             t.setPriority(priority); 
  12.         } 
  13.     } catch (Exception ignored) { 
  14.         // Doesn't matter even if failed to set. 
  15.     } 
  16.     return t; 
  17. } 

这里没有太多的操作，只是会将一个 Runnable封装为一个 Thread进行返回，我们重点关注一下这个Thread，它和我们传统使用的Thread是一样的吗? 我们跟进到 newThread方法看一下：

  1. protected Thread newThread(Runnable r, String name) { 
  2.     //Netty自己封装的线程 
  3.     return new FastThreadLocalThread(threadGroup, r, name); 
  4. } 

逻辑很简单，就是将一个Thread包装为Netty自定义的 FastThreadLocalThread，至于为什么，我们暂时不往下多做解释，后续章节会很详细的解释它!

2. 线程执行器总结

这里我们会创建一个线程执行器 ThreadPerTaskExecutor，使用默认的线程工厂DefaultThreadFactory，线程执行器会将一个任务包装为一个 FastThreadLocalThread对象，然后调用start方法开启一个新的线程执行任务!

三、创建对应数量的执行器

  1. //创建执行器数组  数量和预设线程数量一致 
  2. children = new EventExecutor[nThreads]; 
  3.  
  4. for (int i = 0; i < nThreads; i ++) { 
  5.     boolean success = false; 
  6.     try { 
  7.         //创建执行器  开始创建执行器   这里的执行机估计就会EventLoop  是NioEventLoop 
  8.         children[i] = newChild(executor, args); 
  9.         success = true; 
  10.     } catch (Exception e) { 
  11.         .....省略不必要代码 
  12.     } finally { 
  13.         .....省略不必要代码 
  14.     } 
  15. } 

1. 源码解析

  1. children = new EventExecutor[nThreads]; 

首先他会创建一个空的EventExecutor执行器数组，然后遍历填充!

还记得 nThreads是几吗? 默认是CPU*2的大小，所以这里会创建 CPU * 2数量的执行器! 我们发现，for循环中填充的主要逻辑是newChild，所以，我们进入到 newChild方法, 这里提示一点，我们创建的Group对象是一个什么对象? 是NioEventLoopGroup对象对不对，所以我们这里会进入到 NioEventLoopGroup#newChild方法：

  1. @Override 
  2. protected EventLoop newChild(Executor executor, Object... args) throws Exception { 
  3.     EventLoopTaskQueueFactory queueFactory = args.length == 4 ? (EventLoopTaskQueueFactory) args[3] : null; 
  4.     return new NioEventLoop(this, executor, (SelectorProvider) args[0], 
  5.                             ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2], queueFactory); 
  6. } 

我们传递过来 的args长度为3,前面做过解析 ：

args[0]为 selectorProvider、args[1]为拒绝策略、args[2]为selectStrategyFactory

所以 queueFactory为null， 然后我们再重点关注 NioEventLoop对象，可以看出，newChild方法返回的是 NioEventLoop，那么我们初步就可以确定，EventExecutor数组里面存在的是NioEventLoop对象!至此，我们就不深究了，NioEventLoop的初始化源码分析我会放到下一节课分析，这里我们可以确定一件事， EventExecutor数组里面存在的是NioEventLoop对象!我们继续回到主线：

2. 执行器数组总结

for循环完毕之后，此时的EventExecutor[nThreads];数组就被填充满了，里面的每一个元素都是NioEventLoop对象，每一个NioEventLoop对象都包含一个 ThreadPerTaskExecutor线程执行器对象!

四、创建一个执行器选择器

1. 源码解析

  1. chooser = chooserFactory.newChooser(children); 

还记得 chooserFactory是什么类型的吗? 是DefaultEventExecutorChooserFactory类型的，忘了的可以往上翻一下寻找源码的过程中的代码或者调试一下!

我们进入到 DefaultEventExecutorChooserFactory#newChooser 源码逻辑中，并传入刚刚我们循环填充好的数组：

  1. @Override 
  2. public EventExecutorChooser newChooser(EventExecutor[] executors) { 
  3.     //判断2的幂 isPowerOfTwo 
  4.     if (isPowerOfTwo(executors.length)) { 
  5.         return new PowerOfTwoEventExecutorChooser(executors); 
  6.     } else { 
  7.         //简单的 
  8.         return new GenericEventExecutorChooser(executors); 
  9.     } 
  10. } 

可以看到，这里似乎有两种情况，返回的是不同的策略对象，当你的数组长度是2的幂等次方的时候，返回的是 PowerOfTwoEventExecutorChooser对象，否则返回 GenericEventExecutorChooser对象，我们就两种情况全部分析一下：

I、PowerOfTwoEventExecutorChooser

  1. PowerOfTwoEventExecutorChooser(EventExecutor[] executors) { 
  2.     this.executors = executors; 
  3. } 
  4.  
  5. @Override 
  6. public EventExecutor next() { 
  7.     //2的幂等性  实现这个  也能实现循环取数的 
  8.     //executors   就是NioEventLoop数组  按照2次幂求本次获取的EventLoop是个啥 
  9.     return executors[idx.getAndIncrement() & executors.length - 1]; 
  10. } 

这段代码的主要逻辑是，取一个自增的CAS类，与数组长度做&运算，最终会出现循环取数的结果：

从上面的图片可以基本看出来, 该功能可以实现一个循环取数的功能，每次达到数组的尾部部都会重新回到头部重新获取!

代码案例：

  1. public static void main(String[] args) { 
  2.     String[] strings = {"第一个", "第二个", "第三个", "第四个"}; 
  3.     AtomicInteger idx = new AtomicInteger(); 
  4.     for (int i = 0; i < 9; i++) { 
  5.         System.out.println(strings[idx.getAndIncrement() & strings.length -1]); 
  6.     } 
  7.  
  8. } 

结果集

  1. 第一个 
  2. 第二个 
  3. 第三个 
  4. 第四个 
  5. 第一个 
  6. 第二个 
  7. 第三个 
  8. 第四个 
  9. 第一个 

II、GenericEventExecutorChooser

当你的线程数量不是2的幂次方的时候，会走一个通用的选择器，具体实现源码如下：

  1. GenericEventExecutorChooser(EventExecutor[] executors) { 
  2.     this.executors = executors; 
  3. } 
  4.  
  5. @Override 
  6. public EventExecutor next() { 
  7.     //自增  取模   以达到循环的目的 
  8.     //假设executors 长度为5  那么 不断的循环就会不断的得到 0 1 2 3 4  0 1 2 3 4。。。 
  9.     return executors[Math.abs(idx.getAndIncrement() % executors.length)]; 
  10. } 

这个代码就不用了我做演示了吧，他的功能和上面那个功能是一样的能 能够达到一个循环取数的功能

思考

为什么Netty要分为两个策略类来实现呢，直接用第二种不行吗?

Netty官方对性能的要求达到了极致，大家要知道位运算速度要高于直接取模运算的，所以Netty官方即使是这一点也做了一个优化!

2. 执行器选择器总结

我们通过上述可以了解到，这里会通过一个选择器工厂创建一个选择器，并保存在NioEvenetLoopGroup中，调用该选择器的next方法会返回一个NioEventLoop对象，其中的获取方式是不断的循环，依次获取NioEventLoop对象，这也是一个NioEventLoop对SocketChannel为一对多的基础!这都是后话!

NioEventLoopGroup源码总结

 

  1. 创建一个线程执行器，当调用该线程执行器的execute方法的时候，会讲一个Runable对象包装为Thread对象，再将Thread对象包装为FastThreadLocalThread对象，然后启动起来! 简单来说，每调用一次execute方法，都去创建并启动一条新线程执行任务!
  2. 创建一个执行器数组，数组长度与我们传递的数量有关，默认为CPU*2个数量，然后再循环填充这个空数组，数组里面的元素是一个NioEventLoop对象，每一个NioEventLoop对会持有一个线程执行器的引用!
  3. 创建一个执行器选择器，调用该执行器选择器的next方法可以返回一个NioEventLoop对象，内部是进行循环取数的，每一个NioEventLoop都可能会被多次获取!

 

来源：源码学徒内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

一篇学会NioEventLoopGroup源码解析

后端开发源码参数2024-12-03

一篇学会Caffeine W-TinyLFU源码分析

后端开发Caffeine数据2024-12-03

一篇学会Go网络库Gnet解析

后端开发2023-08-23

一篇学会 Go 网络库 Gnet 解析

后端开发Go网络库2024-12-13

Netty组件NioEventLoopGroup创建线程执行器源码解析

后端开发2024-04-02

一篇带你解析入门LongAdder源码

后端开发2024-04-02

一篇学会逃逸分析，yyds！

后端开发逃逸JVM2024-12-02

【源码篇】安卓源码解析（持续总结）

后端开发2023-10-25

SpringCache源码分析，你学会了吗？

后端开发Spring源码2024-11-30

一篇学会资源库Repository的性能优化

后端开发性能优化2024-12-03

一篇学会理解动态规划

后端开发理解动态2024-12-14

一篇学会 Linux at 命令详解

后端开发Linux2024-12-02

【投屏】Scrcpy源码分析一（编译篇）

后端开发2023-09-13

一篇带给你pod创建源码分析

后端开发pod源码分析2024-12-02

Bootstrap源码分析总结，你学会了吗？

后端开发Bootstrap源码2024-12-01

一篇文章教会你JavaScript json 解析

后端开发JavaScriptjson2024-12-03

一篇文章教会你 JavaScript json 解析

后端开发JSONWeb服务器2024-11-30

一篇了解JVM堆（Heap），你学会了吗？

后端开发HeapJVM2024-12-13

两源码学其一，质量都不会差！

后端开发架构模型2024-11-30

螺旋文字滚动特效源码解析，你学会了吗？

后端开发JavaScriptCSS2024-11-29
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯