Netty源码分析之NioEventLoopGroup创建

最新推荐文章于 2025-05-19 23:42:34 发布
转载 最新推荐文章于 2025-05-19 23:42:34 发布 · 188 阅读 · 1 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/xiaobaituyun/p/10799786.html
文章标签：

#netty

本文主要介绍了Netty中NioEventLoopGroup的创建过程。服务端通常创建两个NioEventLoopGroup，分别用于接收请求和处理网络IO等操作。详细阐述了其构造函数，包括线程数设置、线程构造器、child线程组创建和线程选择器创建等内容，还介绍了相关组件的作用。

NioEventLoopGroup的创建

　　服务端一般是通过创建两个NioEventLoopGroup来创建NioEventLoop，一个NioEventLoopGroup主要是用于接收客户端的请求，另外一个NioEventLoopGroup则是处理网络IO的相关读写操作，或者是执行定时任务，或者是系统任务。

bossGroup = new NioEventLoopGroup();
workerGroup = new NioEventLoopGroup();

NioEventLoopGroup的构造函数：

public NioEventLoopGroup() {
    this(0);
}

public NioEventLoopGroup(int nThreads) {
    this(nThreads, (Executor)null);
}

public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory) {
    this(nThreads, threadFactory, SelectorProvider.provider());
}

public NioEventLoopGroup(int nThreads, Executor executor) {
    this(nThreads, executor, SelectorProvider.provider());
}

public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory, SelectorProvider selectorProvider) {
    this(nThreads, threadFactory, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
}

public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory, SelectorProvider selectorProvider, SelectStrategyFactory selectStrategyFactory) {
    super(nThreads, threadFactory, new Object[]{selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject()});
}

　　可以从默认的构造函数看出来，默认传入的线程数是0，默认传入的ThreadFactory是null，并且传入了一个selectorProvider。最后层层调用了父类MultithreadEventLoopGroup的构造函数。

protected MultithreadEventLoopGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, threadFactory, args);
}

 　　这里会判断传入的线程数是不是等于0，如果等于0，就将线程数设置为2*cpu。默认情况下不传参数，会创建2*cpu个线程数的线程池NioEventLoopGroup。然后继续调用父类构造函数该父类的构造函数。

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, Object... args) {
    this.terminatedChildren = new AtomicInteger();
    this.terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    } else {
        if (executor == null) {
            executor = new ThreadPerTaskExecutor(this.newDefaultThreadFactory());
        }

        this.children = new EventExecutor[nThreads];

        int j;
        for(int i = 0; i < nThreads; ++i) {
            boolean success = false;
            boolean var18 = false;

            try {
                var18 = true;
                this.children[i] = this.newChild((Executor)executor, args);
                success = true;
                var18 = false;
            } catch (Exception var19) {
                throw new IllegalStateException("failed to create a child event loop", var19);
            } finally {
                if (var18) {
                    if (!success) {
                        int j;
                        for(j = 0; j < i; ++j) {
                            this.children[j].shutdownGracefully();
                        }

                        for(j = 0; j < i; ++j) {
                            EventExecutor e = this.children[j];

                            try {
                                while(!e.isTerminated()) {
                                    e.awaitTermination(2147483647L, TimeUnit.SECONDS);
                                }
                            } catch (InterruptedException var20) {
                                Thread.currentThread().interrupt();
                                break;
                            }
                        }
                    }

                }
            }

            if (!success) {
                for(j = 0; j < i; ++j) {
                    this.children[j].shutdownGracefully();
                }

                for(j = 0; j < i; ++j) {
                    EventExecutor e = this.children[j];

                    try {
                        while(!e.isTerminated()) {
                            e.awaitTermination(2147483647L, TimeUnit.SECONDS);
                        }
                    } catch (InterruptedException var22) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }

        this.chooser = chooserFactory.newChooser(this.children);
        FutureListener<Object> terminationListener = new FutureListener<Object>() {
            public void operationComplete(Future<Object> future) throws Exception {
                if (MultithreadEventExecutorGroup.this.terminatedChildren.incrementAndGet() == MultithreadEventExecutorGroup.this.children.length) {
                    MultithreadEventExecutorGroup.this.terminationFuture.setSuccess((Object)null);
                }

            }
        };
        EventExecutor[] var24 = this.children;
        j = var24.length;

        for(int var26 = 0; var26 < j; ++var26) {
            EventExecutor e = var24[var26];
            e.terminationFuture().addListener(terminationListener);
        }

        Set<EventExecutor> childrenSet = new LinkedHashSet(this.children.length);
        Collections.addAll(childrenSet, this.children);
        this.readonlyChildren = Collections.unmodifiableSet(childrenSet);
    }
}

 这里的构造函数主要做了三件事情;

1.创建线程构造器ThreadPerTaskExecutor

2.使用newChild方法创建child线程组

3.创建线程选择器

 

创建线程构造器

　　这里的ThreadPerTaskExecutor相当于是线程池聚合的一个组件，当线程池需要创建线程时，通过该线程构造器去创建一个线程，线程的创建也是工厂模式的一个应用，每次ThreadPerTaskExecutor.execute()都会调用ThreadFactory的newThread()。

public final class ThreadPerTaskExecutor implements Executor {
    private final ThreadFactory threadFactory;

    public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
        if (threadFactory == null) {
            throw new NullPointerException("threadFactory");
        } else {
            this.threadFactory = threadFactory;
        }
    }

    public void execute(Runnable command) {
        this.threadFactory.newThread(command).start();
    }
}

　　而这里传入的threadFactory是一个DefaultThreadFactory。

protected ThreadFactory newDefaultThreadFactory() {
    return new DefaultThreadFactory(this.getClass(), 10);
}

 DefaultThreadFactory的构造函数：

public DefaultThreadFactory(Class<?> poolType, int priority) {
    this((Class)poolType, false, priority);
}
public DefaultThreadFactory(String poolName, boolean daemon) {
    this((String)poolName, daemon, 5);
}

public DefaultThreadFactory(Class<?> poolType, int priority) {
    this((Class)poolType, false, priority);
}

public DefaultThreadFactory(String poolName, int priority) {
    this((String)poolName, false, priority);
}

public DefaultThreadFactory(Class<?> poolType, boolean daemon, int priority) {
    this((String)toPoolName(poolType), daemon, priority);
}

private static String toPoolName(Class<?> poolType) {
    if(poolType == null) {
        throw new NullPointerException("poolType");
    } else {
        String poolName = StringUtil.simpleClassName(poolType);
        switch(poolName.length()) {
            case 0:
                return "unknown";
            case 1:
                return poolName.toLowerCase(Locale.US);
            default:
                return Character.isUpperCase(poolName.charAt(0)) && Character.isLowerCase(poolName.charAt(1))?Character.toLowerCase(poolName.charAt(0)) + poolName.substring(1):poolName;
        }
    }
}
public DefaultThreadFactory(String poolName, boolean daemon, int priority) {
    this.nextId = new AtomicInteger();
    if(poolName == null) {
        throw new NullPointerException("poolName");
    } else if(priority >= 1 && priority <= 10) {
        this.prefix = poolName + '-' + poolId.incrementAndGet() + '-';
        this.daemon = daemon;
        this.priority = priority;
    } else {
        throw new IllegalArgumentException("priority: " + priority + " (expected: Thread.MIN_PRIORITY <= priority <= Thread.MAX_PRIORITY)");
    }
}
public Thread newThread(Runnable r) {
    Thread t = this.newThread(new DefaultThreadFactory.DefaultRunnableDecorator(r), this.prefix + this.nextId.incrementAndGet());

    try {
        if(t.isDaemon()) {
            if(!this.daemon) {
                t.setDaemon(false);
            }
        } else if(this.daemon) {
            t.setDaemon(true);
        }

        if(t.getPriority() != this.priority) {
            t.setPriority(this.priority);
        }
    } catch (Exception var4) {
        ;
    }

    return t;
}

　　这里传入了当前的类类型NioEventLoopGroup,设置当前线程池的名称为nioEventLoopGroup,线程的优先级为5，然后载调用父类构造函数当前线程池的前缀nioEventLoopGroup-线程池id-。

　　当每次进行newThread的时候，会将线程池前缀和当前的线程数传入，所以线程的名称就为nioEventLoopGroup-线程池id-线程数id。

　　例如：nioEventLoopGroup-2-1 代表的是第二个线程池的第一个线程。

protected Thread newThread(Runnable r, String name) {
    return new FastThreadLocalThread(r, name);
}

　　当调用newThread方法时，其实创建的是一个FastThreadLocalThread对象，netty底层的一个Thread对象，对Thread进行了包装，优化了相关的ThreadLocal操作。

 

通过newChild()方法创建NioEventLoop线程组

　　这里的newChild()方法就是创建一个NioEventLoop。

protected EventLoop newChild(Executor executor, Object... args) throws Exception {
    return new NioEventLoop(this, executor, (SelectorProvider)args[0], ((SelectStrategyFactory)args[1]).newSelectStrategy(), (RejectedExecutionHandler)args[2]);
}

 　　NioEventLoop的构造，要传入父线程池，executor,和provider。每一个NioEventLoop都有一个selector与它进行绑定，为了实现IO多路复用。

NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider, SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler) {
    super(parent, executor, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
    if (selectorProvider == null) {
        throw new NullPointerException("selectorProvider");
    } else if (strategy == null) {
        throw new NullPointerException("selectStrategy");
    } else {
        this.provider = selectorProvider;
        NioEventLoop.SelectorTuple selectorTuple = this.openSelector();
        this.selector = selectorTuple.selector;
        this.unwrappedSelector = selectorTuple.unwrappedSelector;
        this.selectStrategy = strategy;
    }
}

 　　调用父类的构造函数。

protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor, boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedHandler) {
    super(parent);
    this.threadLock = new Semaphore(0);
    this.shutdownHooks = new LinkedHashSet();
    this.state = 1;
    this.terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);
    this.addTaskWakesUp = addTaskWakesUp;
    this.maxPendingTasks = Math.max(16, maxPendingTasks);
    this.executor = (Executor)ObjectUtil.checkNotNull(executor, "executor");
    this.taskQueue = this.newTaskQueue(this.maxPendingTasks);
    this.rejectedExecutionHandler = (RejectedExecutionHandler)ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
}

　　父类创建任务队列，如果不是NioEventLoop对应的线程，当是外部线程时，就将任务放入任务队列，否则使用线程执行任务。这里的任务队列是LinkedBlockingQueue

protected Queue<Runnable> newTaskQueue() {
    return new LinkedBlockingQueue();
}

　　NioEventLoop的主要组件就是selector,taskqueue,thread,selector用于IO多路复用，使用selector才能使得一个线程能处理多个连接（channel的事件），而thread就是存储当前NioEventLoop的线程，如果不在当前线程中，那么就将任务提交到任务队列中taskqueue。

 

创建线程选择器

　　线程选择器是对应NioEventLoopGroup.next()方法，每当有一个新的连接进入的时候，NioEventLoopGroup要选择一个NioEventLoop和新连接进行绑定。

 

　　在创建线程选择器的时候会判断当前线程池的个数是不是2的幂次方，如果是就创建一个PowerOfTwoEventExecutorChooser，否则就创建一个GenericEventExecutorChooser。

if(isPowerOfTwo(this.children.length)) {
    this.chooser = new MultithreadEventExecutorGroup.PowerOfTwoEventExecutorChooser(null);
} else {
    this.chooser = new MultithreadEventExecutorGroup.GenericEventExecutorChooser(null);
}

　　普通的线程选择器：

private final class GenericEventExecutorChooser implements MultithreadEventExecutorGroup.EventExecutorChooser {
    private GenericEventExecutorChooser() {
    }

    public EventExecutor next() {
        return MultithreadEventExecutorGroup.this.children[Math.abs(MultithreadEventExecutorGroup.this.childIndex.getAndIncrement() % MultithreadEventExecutorGroup.this.children.length)];
    }
}

　　二的幂次方线程选择器：

private final class PowerOfTwoEventExecutorChooser implements MultithreadEventExecutorGroup.EventExecutorChooser {
    private PowerOfTwoEventExecutorChooser() {
    }

    public EventExecutor next() {
        return MultithreadEventExecutorGroup.this.children[MultithreadEventExecutorGroup.this.childIndex.getAndIncrement() & MultithreadEventExecutorGroup.this.children.length - 1];
    }
}

　　但满足线程数是2的幂次方时，采用&操作来优化，&比%要高效很多。

转载于:https://www.cnblogs.com/xiaobaituyun/p/10799786.html

NioEventLoopGroup
qq_44587855的博客
12-28 978
构造方法 几个入参： int nThreads 线程数量 Executor executor 线程池 SelectorProvider selectorProvider 这个应该比较熟悉了，可以创建selector ThreadFactory threadFactory 线程工厂 SelectStrategyFactory selectStrategyFactory select的策略 RejectedExecutionHandler rejectedExecutionHandler 拒绝策略 Ev..
从register任务看 netty NioEventLoop 的启动流程
oatlmy
12-30 614
结合源码流程，理解 NioEventLoop 的启动流程及核心循环
NioEventLoopGroup中的nThreads和executor
06-19 557
NioEventLoopGroup只传入nThreads即可，创建nThreads个NioEventLoop，boss为NioEventLoop注册建立的channel时，使用默认的ThreadPerTaskExecutor.execute为每个NioEventLoop一对一创建thread，NioEventLoop.run for(;;)一直select 并处理注册的channels。...
二 、netty的NioEventLoopGroup
chizaochun5934的博客
12-22 284
好，我们开始进入netty源码分析的部分。 NioEventLoopGroup我们从名称中便可得知，它是一组NioEventLoop。那么我们接着看NioEventLoop是什么东西，看它的继承关系 最底层的继承来自于ScheduledE...
Netty源码解析之NioEventLoopGroup
0xZzzz的博客
08-25 673
阅读须知 Netty版本：4.1.14.Final 文章中使用/* */注释的方法会做深入分析 正文 在分析BootStrap源码时我们给出的示例程序中，我们看到了NioEventLoopGroup的身影，之前我们分析了NioEventLoop的源码，从命名上就可以看出，NioEventLoopGroup维护了一组NioEventLoop，我们首先看一下它的构造方法，默认无参构造方法...
Netty源码分析:NioEventLoopGroup
wojiushimogui的博客
09-16 6700
Netty学习笔记:NioEventLoopGroup在工作之余，看到自己公司的超哥（俞超）关于Netty的系列博文，讲解的很好，因此，自己在学习之余也跟了下源代码，来了解Netty，也做了相关的笔记，将形成系列博文，这是第一篇。超哥的博文地址在这里：http://www.jianshu.com/p/c5068caab217Netty版本：4.0.23.Final借用超哥的例子，一般服务端的代码如下
Netty源码分析系列之三：Netty启动之NioEventLoop创建
2401_84092832的博客
05-03 1192
2021年的金三银四一眨眼就到了，对于很多人来说是跳槽的好机会，大厂面试远没有我们想的那么困难，摆好心态，做好准备，你也可以的。另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。BAT面试经验实战系列：Spring全家桶+Redis等其他相关的电子书：源码+调优面试真题：《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》
Netty源码分析4:NioEventLoopGroup
heng_zou的博客
03-05 694
NioEventLoopGroup其父类和实现的接口作用分析 NioEventLoopGroup内部维护了一组NioEventLoop，它们之间的关系有点类似于线程池和线程之间的关系，其类图如下：其中Iterable和ScheduledExecutorService属于jdk提供， EventExecutorGroup接口作为Netty定义事件执行器组的顶级接口，主要定义了优雅关闭EventExecutorGroup的方法。其次定义了一个next()方法用于轮询内部的EventExecutor。
【Netty源码系列】—— NioEventLoopGroup初始化（一）
最新发布
supermario19的博客
05-19 845
EventExecutorGroup是通用执行器容器，EventLoopGroup是其网络处理特化版本，大部分能力都是通过委托给内部管理的执行器实现的。
Netty源码分析系列之四：Netty启动之NioServerSocketChannel创建
2401_84092868的博客
05-03 877
即使是面试跳槽，那也是一个学习的过程。只有全面的复习，才能让我们更好的充实自己，武装自己，为自己的面试之路不再坎坷！今天就给大家分享一个Github上全面的Java面试题大全，就是这份面试大全助我拿下大厂Offer，月薪提至30K！我也是第一时间分享出来给大家，希望可以帮助大家都能去往自己心仪的大厂！为金三银四做准备！
netty源码知识点整理二（NioEventLoopGroup）
qq_26855461的博客
07-21 182
学习netty源码知识点整理 创建工作线程： EventLoopGroup workerGroup=new NioEventLoopGroup() new NioEventLoopGroup()最底层源码MultithreadEventExecutorGroup //nThreads如果不传默认是0 如果是0的话 就获取CPU核数的两倍 //executor默认为null //chooserFactory事件执行策略工厂 //args包含：selectorProvider用来创建ServerSocke
netty教程(三)——NioEventLoopGroup创建
yygr的博客
04-20 407
https://juejin.cn/user/1451011081254792/posts 以netty的一个小demo为例（使用的源码版本为4.1.50.Final） demo里使用到了NioEventLoopGroup,一路跟进会调用到这个类一个比较复杂的构函数 public NioEventLoopGroup(int nThreads, Executor executor, final.
Netty--初始化NioEventLoopGroup
Tjimmy的博客
12-24 440
写在这篇博客前！！ 为何要写关于Netty的源码博客呢？ 因为自己最近初学Netty，熟系了Netty的基本操作以及Netty从BIO 到 NIO的一系列进化过程。梳理了Netty所采用的Reactor模型 但是对Netty内部一系列关于Reactor模型的实现有太多的细节需要梳理。所以决心想写一些关于Netty的博客。为了自己能够更加深入Netty以及更加熟悉Netty。 Netty初始化Nio...
Netty源码分析第2章(NioEventLoop)---->第1节: NioEventLoopGroup之创建线程执行器
weixin_30341735的博客
12-31 338
Netty源码分析第2章(NioEventLoop)---->第1节: NioEventLoopGroup之创建线程执行器 Netty源码分析第二章: NioEventLoop 概述: 通过上一章的学习, 我们了解了Server启动的大致流程, 有很多组件与模块并没有细讲, 从这个章开始, 我们开始详细剖析...
死磕Netty源码之Reactor线程模型详解(一)NioEventLoop的启动
黄太洪的博客
07-08 1319
前言 Netty中最核心的就是Reactor线程，对应Netty中的代码就是NioEventLoop。NioEventLoop是通过NioEventLoopGroup进行维护的，所以在介绍NioEventLoop前我们先介绍一下NioEventLoopGroup 博客地址:http://huangth.com GitHub地址:https://github.com/RobertoH...
Netty进阶：Netty核心NioEventLoop原理解析
TheLudlows的博客
10-07 5717
文章目录1. NioEventLoopGroup2. NioEventLoop2.1实例化过程2.2 关联EventLoop3. EventLoop的任务处理机制3.1 register任务3.2 执行任务 Netty提供了Java NIO Reactor模型的实现，之前写过一篇文章是对三种Reactor模式的简单实现:Reactor模型的Java NIO实现,当然netty中的实现要复杂的多。并...
netty源码分析5-NioEventLoopGroup
chenchangqun11的专栏
12-05 512
分享内容如下： NioEventLoopGroup初始化分析 NioEventLoopGroup父子类分析 parentGroup与childGroup区别 1.NioEventLoopGroup初始化分析 从接口类图上看 EventLoopGroup 继承了 线程池和定时线程池功能，判断EventLoopGroup具有线程池的复合功能。从命名猜测 EventLoopGroup 管理了一组...
自顶向下深入分析Netty（四）--EventLoop-1
Fashion-liu的博客
06-16 963
netty线程模型 我们再次回顾这幅图，通过先前的讲解，现在是不是亲切很多了。图中绿色的acceptor应该是你最熟悉的部分，之前我们在ServerBootstrap中进行了详细分析。我们知道了mainReactor是一个线程池，处理Accept事件负责接受客户端的连接；subReactor也是一个线程池，处理Read（读取客户端通道上的数据）、Write（将数据写入到客户端通道上）等事
Netty源码阅读笔记 （一） NioEventLoopGroup的创建
xxy_hl的博客
12-15 210
直接调用NioEventLoopGroup类中的无参构造： public NioEventLoopGroup() { this(0); } 调用单参构造并传入0： public NioEventLoopGroup(int nThreads) { this(nThreads, (Executor) null); } 调用双参构造： publi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值