当前位置： 首页 > web >正文

Vert.x学习笔记-EventLoop与Context的关系

web 2025/7/15 8:56:33
Vert.x学习笔记

      • 1. EventLoop 的核心作用
      • 2. Context 的核心作用
      • 3. EventLoop 与 Context 的关系
        • 1. 事件循环（EventLoop）的核心职责
        • 2. 上下文（Context）的核心职责
        • 3. 事件循环与上下文的关系
          • （1）一对一绑定
          • （2）任务调度协作
          • （3）线程安全保障
        • 4. 关键点总结
        • 5. 代码示例
        • 6. 总结
      • 4. 关键点总结
      • 5. 代码示例
        • 输出示例：
      • 6. 总结

在 Vert.x 中，EventLoop（事件循环）与 Context（上下文）是紧密关联的核心组件，它们共同协作以实现高效、非阻塞的异步编程模型。

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站

在这里插入图片描述

1. EventLoop 的核心作用

  • 事件驱动：EventLoop 是 Vert.x 中处理 I/O 事件的核心机制，负责监听网络事件（如套接字读写）、定时任务等，并将这些事件分发给对应的处理器（Handler）。
  • 线程绑定：每个 EventLoop 通常绑定到一个固定的线程（在 Vert.x 中称为 VertxThread），确保事件处理的线程亲和性，避免线程切换的开销。
  • 非阻塞设计：EventLoop 必须保持非阻塞状态。如果在 EventLoop 线程中执行阻塞操作（如同步 I/O、长时间计算），会导致整个 EventLoop 线程阻塞，从而影响其他事件的及时处理。

2. Context 的核心作用

  • 执行上下文：Context 是 Vert.x 中用于封装和调度异步任务的上下文环境。它负责将任务提交到正确的线程（EventLoop 或 Worker 线程）中执行。
  • 线程隔离：Context 确保同一 Verticle 的所有事件处理逻辑在同一个线程（EventLoop 线程）中执行，避免多线程竞争问题。
  • 任务调度：Context 提供了 runOnContext 和 executeBlocking 等方法，用于将任务提交到当前 Context 关联的线程中执行。

3. EventLoop 与 Context 的关系

  • 一对一绑定：
    每个 Verticle 实例在部署时会被分配到一个 EventLoop，并绑定到一个对应的 Context。这个 Context 封装了该 Verticle 的所有事件处理逻辑，并确保这些逻辑在同一个 EventLoop 线程中执行。

  • 任务调度：
    当 Verticle 中触发一个事件（如 HTTP 请求到达）时，Vert.x 会将该事件的处理任务提交到对应的 Context 中。Context 会将任务调度到绑定的 EventLoop 线程中执行。

  • 避免阻塞：
    如果 Verticle 中需要执行阻塞操作（如数据库查询），可以通过 Context 的 executeBlocking 方法将任务提交到 Worker 线程池中执行，避免阻塞 EventLoop 线程。

在 Vert.x 中，事件循环（EventLoop） 和 上下文（Context） 是紧密协作的核心组件，它们共同构成了 Vert.x 异步编程模型的基础。以下是它们之间关系的详细解析：

1. 事件循环（EventLoop）的核心职责
  • 事件处理引擎：EventLoop 是 Vert.x 中负责监听和处理 I/O 事件（如网络请求、定时任务等）的核心机制。它基于非阻塞 I/O 模型，通过事件驱动的方式处理高并发请求。
  • 线程绑定：每个 EventLoop 通常绑定到一个固定的线程（VertxThread），确保事件处理的线程亲和性。这种设计避免了线程切换的开销，提高了性能。
  • 非阻塞要求：EventLoop 线程必须保持非阻塞状态。如果在 EventLoop 线程中执行阻塞操作（如同步 I/O、长时间计算），会导致整个 EventLoop 线程阻塞，从而影响其他事件的及时处理。
2. 上下文（Context）的核心职责
  • 执行环境封装：Context 是 Vert.x 中用于封装和调度异步任务的上下文环境。它负责将任务提交到正确的线程（EventLoop 线程或 Worker 线程）中执行。
  • 线程隔离与亲和性：Context 确保同一 Verticle 的所有事件处理逻辑在同一个线程（EventLoop 线程）中执行，避免多线程竞争问题。这种线程亲和性是 Vert.x 高性能的关键。
  • 任务调度：Context 提供了 runOnContext 和 executeBlocking 等方法，用于将任务提交到当前 Context 关联的线程中执行。
3. 事件循环与上下文的关系
（1）一对一绑定
  • Verticle 与 Context 的绑定：
    每个 Verticle 实例在部署时会被分配到一个 Context。这个 Context 封装了该 Verticle 的所有事件处理逻辑，并确保这些逻辑在同一个线程中执行。
  • Context 与 EventLoop 的绑定：
    每个 Context 通常绑定到一个 EventLoop 线程（即 Context 的 owner() 方法返回的线程）。这意味着同一 Verticle 的所有事件处理逻辑都会在同一个 EventLoop 线程中执行。
（2）任务调度协作
  • 非阻塞任务：
    当 Verticle 中触发一个事件（如 HTTP 请求到达）时，Vert.x 会将该事件的处理任务提交到对应的 Context 中。Context 会将任务调度到绑定的 EventLoop 线程中执行。
  • 阻塞任务：
    如果 Verticle 中需要执行阻塞操作（如数据库查询），可以通过 Context 的 executeBlocking 方法将任务提交到 Worker 线程池中执行，避免阻塞 EventLoop 线程。
（3）线程安全保障
  • 线程亲和性：
    由于 Context 确保同一 Verticle 的所有事件处理逻辑在同一个 EventLoop 线程中执行，因此无需显式使用同步机制（如锁）来保护共享数据，从而简化了编程模型。
  • 避免多线程竞争：
    Context 将任务隔离到不同的线程中执行（EventLoop 线程或 Worker 线程），避免了多线程竞争问题，提高了程序的稳定性和性能。
4. 关键点总结
  • 线程绑定关系：
    每个 Verticle 实例绑定到一个 Context，每个 Context 绑定到一个 EventLoop 线程。这种层级关系确保了线程亲和性和非阻塞设计。
  • 任务调度机制：
    Context 负责将任务提交到正确的线程中执行。非阻塞任务在 EventLoop 线程中执行，阻塞任务在 Worker 线程中执行。
  • 性能与稳定性：
    通过线程亲和性和任务隔离，Vert.x 实现了高并发、低延迟的异步编程模型，同时避免了多线程竞争问题。
5. 代码示例

以下是一个简单的 Vert.x 示例，展示了 EventLoop 和 Context 的协作：

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Context;
import io.vertx.core.Vertx;
import io.vertx.core.eventloop.EventLoop;public class ExampleVerticle extends AbstractVerticle {@Overridepublic void start() {// 获取当前 Verticle 的 ContextContext context = vertx.getOrCreateContext();// 获取绑定的 EventLoopEventLoop eventLoop = context.owner();System.out.println("Current thread: " + Thread.currentThread().getName());System.out.println("Is EventLoop thread: " + context.isOnEventLoopThread());// 在 EventLoop 线程中执行任务context.runOnContext(v -> {System.out.println("Running on EventLoop thread: " + Thread.currentThread().getName());});// 执行阻塞操作（通过 Worker 线程）context.executeBlocking(promise -> {// 模拟阻塞操作try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}promise.complete("Blocking operation completed");}, res -> {System.out.println("Result: " + res.result());});}public static void main(String[] args) {Vertx vertx = Vertx.vertx();vertx.deployVerticle(new ExampleVerticle());}
}
6. 总结
  • 事件循环（EventLoop） 是 Vert.x 中处理 I/O 事件的核心线程，负责事件分发和非阻塞任务调度。
  • 上下文（Context） 是 Vert.x 中封装和调度异步任务的上下文环境，确保任务在正确的线程中执行。
  • 关系总结：
    每个 Verticle 实例绑定到一个 Context，每个 Context 绑定到一个 EventLoop 线程。Context 负责将任务调度到绑定的 EventLoop 线程或 Worker 线程中执行，确保线程亲和性和非阻塞设计。

通过这种设计，Vert.x 实现了高并发、低延迟的异步编程模型，非常适合构建高性能的网络应用。

4. 关键点总结

  • 线程亲和性：
    EventLoop 和 Context 共同确保同一 Verticle 的所有事件处理逻辑在同一个线程中执行，避免线程切换的开销和多线程竞争问题。

  • 非阻塞设计：
    EventLoop 必须保持非阻塞状态，所有阻塞操作必须通过 Context 提交到 Worker 线程池中执行。

  • 任务隔离：
    Context 将任务隔离到不同的线程中执行（EventLoop 线程或 Worker 线程），确保高并发场景下的性能和稳定性。

5. 代码示例

以下是一个简单的 Vert.x 示例，展示了 EventLoop 和 Context 的协作：

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Context;
import io.vertx.core.Vertx;
import io.vertx.core.eventloop.EventLoop;public class ExampleVerticle extends AbstractVerticle {@Overridepublic void start() {// 获取当前 Verticle 的 ContextContext context = vertx.getOrCreateContext();// 获取绑定的 EventLoopEventLoop eventLoop = context.owner();System.out.println("Current thread: " + Thread.currentThread().getName());System.out.println("Is EventLoop thread: " + context.isOnEventLoopThread());// 在 EventLoop 线程中执行任务context.runOnContext(v -> {System.out.println("Running on EventLoop thread: " + Thread.currentThread().getName());});// 执行阻塞操作（通过 Worker 线程）context.executeBlocking(promise -> {// 模拟阻塞操作Thread.sleep(1000);promise.complete("Blocking operation completed");}, res -> {System.out.println("Result: " + res.result());});}public static void main(String[] args) {Vertx vertx = Vertx.vertx();vertx.deployVerticle(new ExampleVerticle());}
}
输出示例：
Current thread: vert.x-eventloop-thread-0
Is EventLoop thread: true
Running on EventLoop thread: vert.x-eventloop-thread-0
Result: Blocking operation completed
  • 解释：
    • start() 方法在 EventLoop 线程中执行。
    • context.runOnContext 提交的任务也在同一个 EventLoop 线程中执行。
    • context.executeBlocking 提交的任务在 Worker 线程中执行（输出中未显示 Worker 线程名，但实际是异步的）。

6. 总结

  • EventLoop 是 Vert.x 中处理 I/O 事件的核心线程，负责事件分发和非阻塞任务调度。
  • Context 是 Vert.x 中封装和调度异步任务的上下文环境，确保任务在正确的线程中执行。
  • EventLoop 和 Context 的关系：
    每个 Verticle 实例绑定到一个 EventLoop 和一个 Context，Context 负责将任务调度到绑定的 EventLoop 线程或 Worker 线程中执行，确保线程亲和性和非阻塞设计。

通过这种设计，Vert.x 实现了高并发、低延迟的异步编程模型，非常适合构建高性能的网络应用。

Vert.x学习笔记-什么是Handler

spring中的@EnableAutoConfiguration注解详解

Vert.x学习笔记-什么是EventLoop

http://www.xdnf.cn/news/10424.html

相关文章：

  • 图像处理篇---face_recognition库实现人脸检测
  • Linux系统之gettext详解
  • Excel to JSON 插件 2.4.0 版本更新
  • 【java面试】redis篇
  • 【Linux系统】第八节—进程概念（上）—冯诺依曼体系结构+操作系统+进程及进程状态+僵尸进程—详解！
  • 【请关注】ELK集群部署真实案例分享
  • JS中的函数防抖和节流：提升性能的关键技术
  • 设计模式——模版方法设计模式（行为型）
  • 定时任务：springboot集成xxl-job-core（二）
  • Python-Selenium报错截图
  • Go 即时通讯系统：客户端与服务端 WebSocket 通信交互
  • 【HTML-15.3】HTML表单隐藏域深度解析：从基础使用到高级实践
  • Java补充(Java8新特性)(和IO都很重要)
  • LeRobot ACT——LeRobot对ALOHA ACT策略的封装：含源码解析与真机部署(效果比肩ACT原论文)
  • 【量化交易学习】布林线（BOLL）指标
  • uni-app学习笔记二十一--pages.json中tabBar设置底部菜单项和图标
  • NodeJS全栈开发面试题讲解——P6安全与鉴权
  • Java求职者面试指南：DevOps技术栈深度解析
  • [AI算法] 什么事RoPE scaling
  • 精英-探索双群协同优化（Elite-Exploration Dual Swarm Cooperative Optimization, EEDSCO）
  • 26考研——文件管理_文件系统（4）
  • 【JMeter】性能测试知识和工具
  • ARM P15协处理器指令详解：架构、编程与应用实践
  • Spark on Hive表结构变更
  • 2024年数维杯国际大学生数学建模挑战赛A题飞行器激光测速中的频率估计问题解题全过程论文及程序
  • flutter 构建报错Unsupported class file major version 65
  • Java高效处理大文件：避免OOM的深度实践
  • 大语言模型的推理能力
  • 现代前端框架的发展与演进
  • Spring AI调用Ollama+DeepSeek