Netty入门(三):EventLoop
前言
Netty系列索引:
IO相关:
上文提到,早期基于线程的网络模型,处理高并发的能力非常差,随着请求数量的增多,必须不断新建线程,随之带来的问题就是服务器资源被占满、上下文切换成本过高以及IO阻塞导致的CPU浪费。
而Netty则使用了经典Reactor模型,并重新进行了封装,包括EventLoop、EventGroup等。
EventLoopGroup
EventLoopGroup是一个接口,继承自线程池EventExecutorGroup,并允许注册channel到自身所持有的EventLoop,同时支持按一定规则获取下一个EventLoop。
EventLoopGroup的具体实现有很多,下面以DefaultEventLoopGroup为例,简述一下我的理解
1.ScheduledExecutorService
JDK接口,一个延迟或定时任务的执行器,其实现类ScheduledThreadPoolExecutor主要是利用了延时队列及设置下次执行时间来实现的,这里不再赘述(可以单独开个专题0.0)
2.EventExecutorGroup
接口,Netty自定义的一个线程池,负责复用EventExecutor和执行任务
3.EventLoopGroup
核心接口,EventLoopGroup继承自EventExecutorGroup,代表他是一个线程池。同时他具备将channel注册到EventExecutorGroup的功能,代表他是一个能够真正处理Channel的特殊线程池
4.MultithreadEventExecutorGroup(AbstractEventExecutorGroup)
抽象类,实现自EventExecutorGroup接口,提供了一个简易线程池的实现,其只有一个抽象方法newChild(创建EventExecutor)供子类实现
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, Object... args)
4.1 nThreads
private final EventExecutor[] children;
该线程池通过数组存储线程,入参nThreads指定数组大小,并循环调用newChild创建线程。当创建过程中有异常时,会自动调用已创建完成线程的shutdownGracefully方法,进行优雅关闭
for (int i = 0; i < nThreads; i ++) {
boolean success = false;
try {
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;
}
}
}
}
}
4.2 EventExecutorChooserFactory
EventExecutorChooserFactory是一个工厂接口,负责创建EventExecutorChooser
其默认实现DefaultEventExecutorChooserFactory会判断当前线程数是否2的n次幂,如果是则返回PowerOfTwoEventExecutorChooser,否则返回GenericEventExecutorChooser
4.3 EventExecutorChooser
private final EventExecutorChooserFactory.EventExecutorChooser chooser;
EventExecutorChooser负责根据一定规则从线程池children数组中取得下一个线程
PowerOfTwoEventExecutorChooser:通过&运算,将超出executors.length的位置为0
public EventExecutor next() {
return executors[idx.getAndIncrement() & executors.length - 1];
}
GenericEventExecutorChooser:通过求余运算,获取有效index
public EventExecutor next() {
return executors[Math.abs(idx.getAndIncrement() % executors.length)];
}
可以看出当线程数是2的n次幂时,Netty通过与运算优化了效率
5.MultithreadEventLoopGroup
抽象类,继承自MultithreadEventExecutorGroup并实现了EventLoopGroup接口,代表此抽象类是一个可以注册并处理channel的线程池
值得关注的是next方法,他把返回值的类型,进一步限定为EventLoop
public EventLoop next() {
return (EventLoop) super.next();
}
6.DefaultEventLoopGroup
MultithreadEventLoopGroup的一个默认实现
其核心就是实现了newChild方法返回一个EventLoop extends EventExecutor实例
protected EventLoop newChild(Executor executor, Object... args) throws Exception {
return new DefaultEventLoop(this, executor);
}
7.总结
说白了EventLoopGroup核心方法,register负责将channel与线程池中某一线程绑定,next负责返回下一个线程供调用方执行任务
EventLoop
EventLoop直译为事件循环,他的职责简单来说就是绑定一个唯一的线程,去执行或调度被分配的任务。
可见一个EventLoop实例可以为多个channel服务,而为了最大化利用资源,Netty使用池化技术将EventLoop放入EventLoopGroup中管理。
EventLoop的具体实现有很多,先看下DefaultEventLoop的类图,会发现他和DefaultEventLoopGroup的类图很像,都继承了EventLoopGroup接口,但其最大的不同是红框所示,他还继承了EventExecutor,下面主要讲一下多出来的这部分到底是干了什么
1.EventExecutor
接口,定义了一个事件执行器,主要方法如下
/**
* 直接返回自身
*/
@Override
EventExecutor next();
/**
* 返回所属线程池
*/
EventExecutorGroup parent();
/**
* 判断当前线程是否是当前EventLoop绑定的线程
*/
boolean inEventLoop();
/**
* 判断传入线程是否是当前EventLoop绑定的线程
*/
boolean inEventLoop(Thread thread);
(还涉及一些Future异步编程的一些东西,太复杂了后续再填坑吧0.0)
2.AbstractScheduledEventExecutor (AbstractEventExecutor)
抽象类,简单定义了一个支持延迟(定时)任务的执行器
//延时队列
PriorityQueue<ScheduledFutureTask<?>> scheduledTaskQueue;
//下一个任务id
long nextTaskId;
重要方法scheduled
private <V> ScheduledFuture<V> schedule(final ScheduledFutureTask<V> task) {
if (inEventLoop()) {
//如果和执行器绑定的线程一致,直接放入延时队列中
scheduleFromEventLoop(task);
} else {
//获取任务最晚执行时间
final long deadlineNanos = task.deadlineNanos();
// task will add itself to scheduled task queue when run if not expired
if (beforeScheduledTaskSubmitted(deadlineNanos)) {
//放入线程池执行
execute(task);
} else {
//与execute类似,但不保证任务会在执行非延迟任务或执行程序关闭之前运行,默认实现只是委托给execute(Runnable)
lazyExecute(task);
// Second hook after scheduling to facilitate race-avoidance
if (afterScheduledTaskSubmitted(deadlineNanos)) {
execute(WAKEUP_TASK);
}
}
}
return task;
}
3.SingleThreadEventExecutor
抽象类,定义了一个单线程顺序执行器
private void execute(Runnable task, boolean immediate) {
boolean inEventLoop = inEventLoop();
//添加到任务队列
addTask(task);
if (!inEventLoop) {
//启动线程
startThread();
//如果线程池已经关闭,调用拒绝方法
if (isShutdown()) {
boolean reject = false;
try {
if (removeTask(task)) {
reject = true;
}
} catch (UnsupportedOperationException e) {
// The task queue does not support removal so the best thing we can do is to just move on and
// hope we will be able to pick-up the task before its completely terminated.
// In worst case we will log on termination.
}
if (reject) {
reject();
}
}
}
//唤醒线程
if (!addTaskWakesUp && immediate) {
wakeup(inEventLoop);
}
}
4.SingleThreadEventLoop
public abstract class SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop
EventLoop的抽象基类,负责在单线程中执行所有被提交的任务,同时具有注册和处理channle的能力
5.DefaultEventLoop
单线程任务执行器的默认实现,主要就是其实现的run方法
protected void run() {
//循环阻塞的获取任务,知道被通知关闭
for (;;) {
Runnable task = takeTask();
if (task != null) {
task.run();
updateLastExecutionTime();
}
if (confirmShutdown()) {
break;
}
}
}
6.总结
通过以上分析,不难看出Netty首先定义了自己的线程池(EventExectorGroup)和执行器(EventExector),然后通过继承的方式定义了线程池(EventLoopGroup)和执行器(EventLoop),从而添加了处理(注册)channel的能力。
You gotta grab what you can when you can.
机不可失,时不我待。
本文来自博客园,作者:十三,转载请注明原文链接:https://www.cnblogs.com/hystrix/p/15110057.html