Netty20——Netty 核心组件 EventLoop 剖析

最新推荐文章于 2024-06-22 22:09:14 发布
最新推荐文章于 2024-06-22 22:09:14 发布
阅读量358 收藏
点赞数
分类专栏： Netty 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rubulai/article/details/123489484
版权
一、EventLoop的继承关系
EventLoopGroup bossGroup = new NioEventLoopGroup(1);

 在使用Netty时，上面的代码是必不可少的，即创建一个EventLoop对象，EventLoop的类继承关系如下：
在这里插入图片描述
 ①ScheduledExecutorService接口表示是一个定时任务接口，即EventLoop可以接受定时任务。
 ②EventLoop接口：Netty接口文档说明了该接口的作用，一旦Channel注册了，就处理该Channel对应的所有IO操作。
 ③SingleThreadEventExecutor表示这是一个单个线程的线程池。
 ④EventLoop是一个单例的线程池，里面含有一个死循环的线程不断的做着3件事情：监听端口、处理端口事件、处理队列事件。每个EventLoop都可以绑定多个Channel，而每个Channel始终只能由一个EventLoop来处理。

二、NioEventLoop的使用

 对于EventLoop的使用，主要就是eventLoop.excute(task)的调用过程，该方法的实现在SingleThreadEventExecutor类中：

@Override
public void execute(Runnable task){
	if(task == null){
    	throw new NullPointerException("task");
	}
	boolean inEventLoop = inEventLoop();
	if(inEventLoop ){
		addTask(task);
	}else{
		startThead();
		addTask(task);
		if(isShutdown() && removeTask(task)){
			reject();
		}
	}
	if(!addTaskWakesUp && wakesUpForTask(task)){
		wakeup(inEventLoop);
	}
}

 ①首先判断该EventLoop的线程是否是当前线程，如果是，直接添加到任务队列中，否则则尝试启动线程(由于线程是单个的，因此只能启动一次)，随后再将任务添加到队列中。
 ②如果线程已经停止，并且删除任务失败，则执行拒绝策略，默认的拒绝策略是抛出异常。
 ③如果addTaskWakesUp是false，且任务不是NonWakeupRunnable类型，就尝试唤醒selector，这时阻塞在selector的线程就会立即返回。
 addTask(task)的源码：

protected void addTask(Runnable task){
	if(task == null){
		throw new NullPointerException("task");
	}
	if(!offerTask(task)){
		reject(task);
	}
}

final boolean offerTask(Runnable task){
	if(isShutdown()){
		reject();
	}
	// 将任务加入队列
	return taskQueue.offer(task);
}
三、NioEventLoop的父类SingleThreadEventExecutor的startThread方法

 当执行execute()方法的时候，如果当前线程不是EventLoop所属线程，则尝试启动线程，也就是会调用startThread()：

private void startThread(){
	if(state == ST_NOT_STARTED){
		try{
			doStartThread();
		}catch(Throwable cause){
			STATE_UPDATER.set(this,ST_NOT_STARTED);
			PlatformDependent.throwException(cause);
		}
	}
}

 该方法首先判断线程是否启动过了，保证EventLoop只有一个线程，如果没有启动过，则尝试使用CAS将state的状态改为ST_STARTED，也就是将线程的启动状态改为已启动。然后调用doStartThread方法，若失败则回滚线程状态为未启动。doStartThread()的代码如下：

private void doStartThread(){
	executor.execute(new Runnable(){
		@Override
		public void run(){
			boolean success = false;
			updateLastExecutionTime();
			try{
				SingleThreadEventExecutor.this.run();
				success = true;
			}finally{
				for(;;){
					int oldState = state;
					if(oldState >= ST_SHUTTING_DOWN || STATE_UPDATER.compareAndSet(SingleThreadEventExecutor.this,oldState,ST_SHUTTING_DOWN)){
						break;
					}
				}
				try{
					for(;;){
						if(confirmShutdown()){
							break;
						}
					}
				}finally{
					try{
						cleanup();
					}finally{
						STATE_UPDATER.set(SingleThreadEventExecutor.this,ST_TERMINATED);
						threadLock.release();
						terminationFuture.setSuccess(null);
					}
				}
			}
		}
	});
}

 ①首先调用executor的execute()方法，这个executor就是在创建EventLoopGroup的时候创建的ThreadPerTaskExecutor类，该execute方法会将Runnable包装成Netty的FastThreadLocalThread。
 ②任务中首先判断线程中断状态，然后设置最后一次的执行时间。
 ③执行当前NioEventLoop的run方法，注意：这个方法是个死循环，是整个EventLoop的核心。
 ④在finally块中，使用CAS不断修改state的状态，尝试将其改成ST_SHUTTING_DOWN，也就是当线程Loop结束的时候，关闭线程。最后还要死循环确认是否关闭，否则不会break，然后执行cleanup操作，更新状态为ST_TERMINATED，并释放当前线程锁。如果任务队列不是空，则打印队列中还有多少个未完成的任务，并回调terminationFuture的setSuccess方法。

四、NioEventLoop的run()
@Override
protected void run() {
    for (;;) {
        try {
            switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                case SelectStrategy.CONTINUE:
                    continue;
                case SelectStrategy.SELECT:
                    select(wakenUp.getAndSet(false));
                    if (wakenUp.get()) {
                        selector.wakeup();
                    }
                    // fall through
                default:
            }

            cancelledKeys = 0;
            needsToSelectAgain = false;
            final int ioRatio = this.ioRatio;
            if (ioRatio == 100) {
                try {
                    processSelectedKeys();
                } finally {
                    // Ensure we always run tasks.
                    runAllTasks();
                }
            } else {
                final long ioStartTime = System.nanoTime();
                try {
                    processSelectedKeys();
                } finally {
                    // Ensure we always run tasks.
                    final long ioTime = System.nanoTime() - ioStartTime;
                    runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
        // Always handle shutdown even if the loop processing threw an exception.
        try {
            if (isShuttingDown()) {
                closeAll();
                if (confirmShutdown()) {
                    return;
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
    }
}

 整个run()方法做了3件事：
  select获取感兴趣的事件；
  processSelectedKeys处理事件；
  runAllTasks执行队列中的任务；
 select()方法的代码如下：

private void select(boolean oldWakenUp) throws IOException {
    Selector selector = this.selector;
    try {
        int selectCnt = 0;
        long currentTimeNanos = System.nanoTime();
        long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);
        for (;;) {
            long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;
            if (timeoutMillis <= 0) {
                if (selectCnt == 0) {
                    selector.selectNow();
                    selectCnt = 1;
                }
                break;
            }

            if (hasTasks() && wakenUp.compareAndSet(false, true)) {
                selector.selectNow();
                selectCnt = 1;
                break;
            }

            int selectedKeys = selector.select(timeoutMillis);
            selectCnt ++;

            if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {
                break;
            }
            if (Thread.interrupted()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Selector.select() returned prematurely because " +
                            "Thread.currentThread().interrupt() was called. Use " +
                            "NioEventLoop.shutdownGracefully() to shutdown the NioEventLoop.");
                }
                selectCnt = 1;
                break;
            }

            long time = System.nanoTime();
            if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {
                // timeoutMillis elapsed without anything selected.
                selectCnt = 1;
            } else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
                    selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
                logger.warn(
                        "Selector.select() returned prematurely {} times in a row; rebuilding Selector {}.",
                        selectCnt, selector);

                rebuildSelector();
                selector = this.selector;

                // Select again to populate selectedKeys.
                selector.selectNow();
                selectCnt = 1;
                break;
            }

            currentTimeNanos = time;
        }

        if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS) {
            if (logger.isDebugEnabled()) {
                logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
                        selectCnt - 1, selector);
            }
        }
    } catch (CancelledKeyException e) {
        if (logger.isDebugEnabled()) {
            logger.debug(CancelledKeyException.class.getSimpleName() + " raised by a Selector {} - JDK bug?",
                    selector, e);
        }
        // Harmless exception - log anyway
    }
}

 调用selector的select()方法默认阻塞1秒钟，如果有定时任务，则在定时任务剩余时间的基础上再加上0.5秒的阻塞时间。当执行execute方法的时候，也就是添加任务的时候，唤醒selector，防止selector阻塞时间过长。

五、EventLoop运行机制小结

 每次执行execute方法都是向队列中添加任务，当第一次添加时就启动线程，执行run方法。而run方法是整个EventLoop的核心，在run方法中一直不停的循环做3件事：
 1、调用selector的select方法，默认阻塞1秒钟，如果有定时任务，则在定时任务剩余时间的基础上再加上0.5秒进行阻塞。当执行execute方法的时候，也就是添加任务的时候，唤醒selector，防止selector阻塞时间过长。
 2、当selector返回的时候，会调用processSelectedKeys方法对selectKey进行处理。
 3、当processSelectedKeys方法执行结束后，则按照ioRatio的比例执行runAllTasks方法，默认是IO任务时间和非IO任务时间是相同的，用户可以根据自己的应用特点进行调整。比如非IO任务比较多，那么就将ioRatio调小一点，这样非IO任务就能执行长一点时间，防止队列积攒过多的任务。

阿弥陀佛僧
关注
专栏目录
Netty之EventLoopGroup详解
zaltan_cgw的博客
03-14 6145
Netty之EventLoopGroup详解EventLoopGroup EventLoopGroup netty是一款全异步，无阻塞的高性能框架，这篇文章着重讲了事件循环组的原理。 在之前，先讲一下netty的流程 netty是一款非阻塞框架，acceptor接收请求，poller起select的作用，像一个列车一样，把请求来回在acceptor和线程池之间传递，因为如果没有poller，就不...
Netty大战之Netty 核心组件 EventLoop 源码剖析
亚索@哈塞给
07-30 172
源码剖析目的 Echo第一行代码就是 ：EventLoopGroup bossGroup = new NioEventLoopGroup(1); 下面分析其最核心的组件 EventLoop NioEventLoopGrop的拓扑图 源码剖析
【Netty】EventLoop组件
最新发布
m0_62645012的博客
06-22 232
EventLoopGroup 是一组 EventLoop，Channel 一般会调用 EventLoopGroup 的 register 方法来绑定其中一个 EventLoop，后续这个 Channel 上的 io 事件都由此 EventLoop 来处理（保证了 io 事件处理时的线程安全）到关闭状态从而拒绝新的任务的加入，然后在任务队列的任务都处理完成后，停止线程的运行。客户端，启动三次，分别修改发送字符串为 zhangsan（第一次），lisi（第二次），wangwu（第三次）它的继承关系比较复杂。
Netty的核心组件——Channel、EventLoop、ChannelPipeline和Handler
程序员阿皓的博客
03-24 653
上面代码，创建了一个EventLoopGroup来处理事件循环，设置了Bootstrap来配置客户端引导程序，初始化了一个ChannelPipeline并添加了一个自定义的ChannelHandler来处理事件。最后，我们连接到远程主机并等待连接关闭。Netty 是一个异步事件驱动的网络应用框架，用于快速开发可维护的高性能服务器和客户端。：用于处理入站和出站数据以及事件。：是处理所有的I/O事件和任务的线程。：代表了一个到远程节点的连接，如一个。
Netty之EventLoop 解读
一个菜鸡的博客
06-04 1182
定时任务：通过调用 NioEventLoop 的 schedule() 方法向定时任务队列 scheduledTaskQueue 添加一个定时任务，用于周期性执行该任务。例如，心跳消息发送等。NioEventLoop 不仅负责处理 I/O 事件，还要兼顾执行任务队列中的任务。客户端代码不变，启动三次，分别修改发送字符串为 zhangsan（第一次），lisi（第二次），wangwu（第三次）客户端，启动三次，分别修改发送字符串为 zhangsan（第一次），lisi（第二次），wangwu（第三次）
netty的eventLoop组件
weixin_30575309的博客
10-30 70
用最实用的NioEventLoop来看，其实，一个事件循环是一个内建selector的线程罢了，eventLoop是事件循环的意思，说明这个线程一直在执行，而且一直在循环的执行，知道外部给下下命令，让它停止。 基本的事件循环写法 　　for(;;){ 　　　　//做一些事情 　　} 最基本的写法。在循环里面，要处理网络读写，还有用户任务的处理，这里为什么要处理用户任务也放到事件循环...
Netty框架入门篇 - 核心组件再认识
wzljiayou的博客
11-28 3965
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 为什么Eventloop设计时，需要保证同一个线程才能执行任务；由于往网络上传输数据需要提供个API供业务线程进行调用，而在Netty中channel都会绑定一个Eventloop，由Eventloop对应的线程来传输数据。Netty就是为了避免业务线程与Eventloop中的线程同时写数据造成冲突，于是，就采用了这种机制，也就是业务线程需要传输数据时，必须
Netty源码分析：三大核心组件——ChannelPipline、ChannelHandler、ChannelHandlerContext
保暖透气大裤衩LeoLee的博客
10-31 580
三者关系 每当ServerSocket建立一个新的连接后，就会创建一个Socket，对应目标客户端 每当创建一个Socket将会分配一个新的ChannelPipeline 每个ChannelPipline内包含多个ChannelHandlerContext，组成一个双向链表 这些ChannelHandlerContext用来包装我们添加的ChannelHandler 这是一个带有过滤器性质的责任链模式 ChannelPipline提供了许多对ChannelHandler操作的方法.
Netty——源码解析
weixin_43415481的博客
05-13 1448
JAVA后端开发知识总结（持续更新…） Netty—— 文章目录Netty——零、前言一、Netty服务器启动源码 零、前言 在 io.netty.example 包下，有很多 Netty 源码案例，可以用来分析。 一、Netty服务器启动源码 源码需要剖析到 Netty 中调用 doBind 方法，追踪到 NioServerSocketChannel 的 doBind。 同时要 Debug 程序到 NioEventLoop 类的 run 方法，无限循环，在服务器端运行。 ...
netty-4.1.4-jar包
11-23
这个“netty-4.1.4-jar包”包含了两个重要的文件：“netty-all-4.1.17.Final.jar”和“netty-all-4.1.17.Final-sources.jar”，它们是Netty框架的特定版本——4.1.17.Final的组件。 首先，我们来看“netty-all-...
RocketMQ——与Netty的结合
IT1224的博客
01-31 3274
RocketMQ作为一个高效的分布式消息队列，通信质量是必须保证的，而Netty是一个高效的网络应用框架，因此RocketMQ选择Netty来实现底层的通信功能。 Netty介绍       Netty是一个高效的JAVA网络应用框架，它提供异步事件驱动的方式，使用Netty可以快速开发出高性能的网络应用程序。  &nb...
详解netty 线程模型及`EventLoop`
zhangshenglu1的博客
04-24 501
详解netty 线程模型及EventLoop 一、线程模型 linux下网络并发线程模型主要有下面五种 1、apache模型： 为每一种连接分配一个进程。主机分配给每个连接的时间和空间代价大，并且随着连接的增多，进程间切换开销也增长了，很难应对大量的客户并发连接。 2、TPC模型（Thread per connection): 每个线程对应一个连接。比apache模型好，但是还是存在性能开销大的问...
Netty 学习（三）EventLoop
大鱼的博客
11-02 468
理解 Netty 的 Reactor 线程模型和它的核心处理引擎 EventLoop。
Netty框架学习之路（五）—— EventLoop及事件循环机制
懋懋之为
03-30 8125
在前面的博文中，我们大致分析了解了Channel及其相关概念。在Netty的线程模型中，每个channel都有唯一的一个eventLoop与之相绑定，那么在这篇博文中我们来看一下EvenLoop及其相关概念。 在传统的Java NIO编程中，我们经常使用到如下代码： public static void main(String[] args) { try { ...
Netty学习笔记（四）—— EventLoop 和 EventLoopGroup
qq_23016999的博客
08-28 1246
之前我们谈过 Channel 和 Unsafe 是用于操作 bind、connect、read、write等底层的网络传输，其大大降低了使用 Socket 类的复杂性。而 EventLoop 则是用于多线程、并发地处理连接生命周期中所发生的事件。因此选择合适的线程模型能有效地提高系统性能。 本文目录 1 Netty的线程模型 1.1 Reactor单线程模型 1.2 Reactor多线...
netty权威指南 - EventLoop事件循环
qq_42312907的博客
06-21 364
netty作为一个高性能网络框架，基于java线程实现了自己的线程模型，即EventLoop事件循环。 传统线程模型 在传统的java网络编程中，IO逻辑是同步阻塞的。也就是说，每次创建一个socket连接，就会有一个线程与该socket绑定，该线程不会去处理其他socket。如果有100个请求同时到来，会使用100个线程来处理。如果有200个请求同时到来，但是线程池中只有100个线程，那就只会同时处理100个请求，剩下100个请求阻塞在队列中。 在实际的编程开发中，有两个原则： IO性能比计算性能低。按
根据NioEventLoop的继承实现关系来理解其功能
weixin_43354959的博客
05-23 178
Netty入门——组件（EventLoop）
小志的博客
11-01 649
Netty入门——组件（EventLoop）
Netty（6）netty组件：EventLoop、Channel、Future和Promise、Handler和Pipeline
учёба
08-22 470
可以理解为：事件循环对象是一个（同时维护了一个 Selector），里面有 run 方法继承关系，查看源码可知： 可以理解为：事件循环组 一般我们不会直接使用EventLoop，而是使用EventLoopGroupEventLoopGroup 是，继承自 netty 自己的 EventExecutorGroup 执行普通任务 好处： 执行定时任务 用途：在实现keep-alive时，实现任务的保活 处理IO事件 服务器端 在服务器端做了两个细分： 客户端 运行 debug输入数据 按下面的操作，便可
深入解析Netty：线程模型与EventLoop
"本文主要探讨了Netty框架中与线程相关的源码分析，包括NioEventLoopGroup和NioEventLoop之间的关系、线程池的创建以及EventLoop的初始化过程。" 在Netty框架中，线程模型对于高效处理网络通信至关重要。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值