Vert.x学习笔记-Vert.x的基本处理单元Verticle

Verticle介绍

Verticle是Vert.x的基本处理单元，Vert.x应用程序中存在着处理各种事件的处理单元，比如负责HTTP API响应请求的处理单元、负责数据库存取的处理单元、负责向第三方发送请求的处理单元。Verticle就是对这些功能单元的封装，Verticle可被部署，有自己的生命周期，Verticle是Vert.x中构建异步事件处理程序及相关业务逻辑的基础。

Verticle特点

Verticle是Vert.x框架的核心概念，它是一种单一组件，所有业务功能都使用这种组件来完成。

• 简单性（Simplicity） ：Vert.x的设计采用了单一组件结构，即Verticle，这使得所有业务功能都使用同一种组件进行编程，从而让开发人员能够快速适应Vert.x编程，并加快项目的开发速度。
• 并发性（Concurrency） ：在处理多用户并发连接请求时，Vert.x摒弃了传统的多线程、同步工作、阻塞模式，而采用简单的单线程、异步工作、非阻塞模式，通过单线程内的事件驱动实现并发处理。这种处理方式更高效地利用了系统资源，并能够更好地应对高并发场景。
• 线程隔离性（Thread Isolation） ：Verticle的最大特色就是它的线程隔离性。在启动时，Verticle就被分配给了创建和start方法调用的Event Loop。当调用一个使用core API的handler的方法时，Vert.x保证这些handler将在同一个Event Loop上执行。这种线程隔离性可以保证在Verticle实例的代码是在同一个Event Loop执行，避免了多线程环境下的并发问题。

实现原理

Verticle的实现原理主要基于事件驱动和非阻塞I/O模型。在Vert.x中，应用程序将业务逻辑封装在事件驱动的处理程序中，称为Verticle。每个Verticle都是一个独立的运行单元，可以按照一定规则通过时间和状态变换来实现。
具体来说，当外部系统或客户端发起请求时，Vert.x会将请求转换为处理程序可以处理的标准格式，并将处理结果返回给客户端。在这个过程中，Vert.x采用了异步消息传递的方式，使得不同Verticle之间可以相互通信。
此外，Vert.x还提供了容器来为Verticle提供运行的环境和服务，并支持将多个Verticle部署在同一容器中。当一个Verticle需要访问网络服务器时，它可以通过容器来获取相应的服务，并且当多个Verticle实例被部署时，事件会按照轮询的方式分发到每个Verticle实例，这有助于在大量并发网络请求时最大化CPU使用率。
总之，Verticle的实现原理是基于事件驱动和非阻塞I/O模型，通过将业务逻辑封装在事件驱动的处理程序中，并借助容器提供运行环境和服务的支持，实现了高效、可扩展、易于使用的应用程序开发方式。

接口定义

public interface Verticle {

  /**
   * Get a reference to the Vert.x instance that deployed this verticle
   * 获取一个Vert.x实例的引用用来发布当前的verticle
   */
  Vertx getVertx();

  /**
   * Initialise the verticle with the Vert.x instance and the context.
   * 通过Vert.x实例和上下文来初始化一个Verticle
   * <p>
   * This method is called by Vert.x when the instance is deployed. You do not call it yourself.
   *
   * @param vertx  Vert.x实例
   * @param context 上下文
   */
  void init(Vertx vertx, Context context);

  /**
   * Start the verticle instance.
   * 启动当前的verticle实例
   * <p>
   * Vert.x calls this method when deploying the instance. You do not call it yourself.
   * <p>
   * A promise is passed into the method, and when deployment is complete the verticle should either call
   * {@link io.vertx.core.Promise#complete} or {@link io.vertx.core.Promise#fail} the future.
   *
   * @param startPromise  the future
   */
  void start(Promise<Void> startPromise) throws Exception;

  /**
   * Stop the verticle instance.
   * 停止当前的verticle实例
   * <p>
   * Vert.x calls this method when un-deploying the instance. You do not call it yourself.
   * <p>
   * A promise is passed into the method, and when un-deployment is complete the verticle should either call
   * {@link io.vertx.core.Promise#complete} or {@link io.vertx.core.Promise#fail} the future.
   *
   * @param stopPromise  the future
   */
  void stop(Promise<Void> stopPromise) throws Exception;
}

Verticle编写

在日常的开发中，我们通常会采用继承AbstractVerticle抽象类的方式来实现自定义的Verticle，理论上来说，我们也可以通过实现Verticle接口的方式来定义一个Verticle实现类，但是开发人员通常会通过继承AbstractVerticle的方式来实现，因为它提供了所有Vert.x用户都会用到的事件处理程序、配置信息、执行流水线等。

Vert.x是一个库，而不是一个框架，所以你既可以选择从main方法中创建Vert.x实例，也可以选择从任何其它类中来创建，先创建好Vert.x，再部署Vertcle

一个Verticle的生命周期由start和stop事件组成，AbstractVerticle类提供了start和stop方法，我们可以覆盖它们

• start：设置初始化工作，初始化事件处理程序，启动Http服务端口监听等

• stop： 执行一些清理任务，例如关闭数据库连接，停止Http端口监听等

默认情况，这两个方法什么都不做

代码实例

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloVerticle extends AbstractVerticle {

  private final Logger logger = LoggerFactory.getLogger(HelloVerticle.class);
	
  //定义一个全局变量	
  private long counter = 1;

  @Override
  public void start() {
  
	//定义一个每5秒执行一次的周期性任务
    vertx.setPeriodic(5000, id -> {
      logger.info("tick");
    });
	
	//定义一个HttpServer，监听8080端口
    vertx.createHttpServer()
      .requestHandler(req -> {
        logger.info("Request #{} from {}", counter++, req.remoteAddress().host());
        req.response().end("Hello!");
      })
      //监听8080端口
      .listen(8080);

    logger.info("Open http://localhost:8080/");
  }

  public static void main(String[] args) {
  	//实例化一个全局的Vert.x实例
    Vertx vertx = Vertx.vertx();
    //部署一个Verticle
    vertx.deployVerticle(new HelloVerticle());
  }
}

通过执行上面的实例代码，可以得出一个Verticle的重要属性：事件处理是在单个事件循环线程上进行的，从日志可以看出来，他们都是在 vert.x-eventloop-thread-0 这个线程上进行执行的，该设计的好处就在于在同一个线程上进行，减少了锁对性能的影响，同时减少了线程切换的开销，

代码实例交互过程

HelloVerticle调用Vert.x对象上的setPeriodic创建周期性任务处理程序，该对象又使用Vert.x定时器创建周期性任务，反过来，定时器定时回调HelloVerticle中的InternalTimerHandler处理程序

事件循环线程与Verticle的关系

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloVerticle extends AbstractVerticle {

  private final Logger logger = LoggerFactory.getLogger(HelloVerticle.class);

  private long counter = 1;
  public long delay;
  public int port;
  HelloVerticle (long delay, int port) {
    this.delay = delay;
    this.port = port;
  }
  public void start() {
    start(delay, port);
  }

  public void start(long delay, int port) {

    vertx.setPeriodic(delay, id -> {
      logger.info("tick : " + delay);
    });

    vertx.createHttpServer()
      .requestHandler(req -> {
        logger.info("Request #{} from {}", counter++, req.remoteAddress().host());
        req.response().end("Hello!");
      })
      .listen(port);

    logger.info("Open http://localhost:" + port);
  }

  public static void main(String[] args) {
    Vertx vertx = Vertx.vertx();
    vertx.deployVerticle(new HelloVerticle(5000, 8080));

    vertx.deployVerticle(new HelloVerticle(3000, 8081));
  }
}

通过运行上面的服务并查看对应的日志，就会发现每一个Verticle实例对应了一个独立的事件循环线程

阻塞和事件循环

事件处理程序运行再事件循环线程上，所以这里需要特别注意的一个点：在事件循环的线程中执行的代码所用时间要尽可能短，这样事件循环才能有更高的吞吐量处理大量的事件。所以程序员不应该在事件循环线程中执行耗时太长的任务或进行阻塞IO的操作
下面通过一个代码实例来展示一下当我们故意阻塞事件循环线程后的情形：

public class BlockEventLoop extends AbstractVerticle {

  @Override
  public void start() {
  	//定义一个1000毫秒延时的定时器
    vertx.setTimer(1000, id -> {
    	//进入死循环，模拟阻塞
      while (true);
    });
  }

  public static void main(String[] args) {
    Vertx vertx = Vertx.vertx();
    vertx.deployVerticle(new BlockEventLoop());
  }
}

运行结果：

WARN [vertx-blocked-thread-checker] BlockedThreadChecker - Thread Thread[vert.x-eventloop-thread-0,5,main] has been blocked for 2592 ms, time limit is 2000 ms
WARN [vertx-blocked-thread-checker] BlockedThreadChecker - Thread Thread[vert.x-eventloop-thread-0,5,main] has been blocked for 3596 ms, time limit is 2000 ms
WARN [vertx-blocked-thread-checker] BlockedThreadChecker - Thread Thread[vert.x-eventloop-thread-0,5,main] has been blocked for 4600 ms, time limit is 2000 ms
WARN [vertx-blocked-thread-checker] BlockedThreadChecker - Thread Thread[vert.x-eventloop-thread-0,5,main] has been blocked for 5603 ms, time limit is 2000 ms
io.vertx.core.VertxException: Thread blocked
	at app//chapter2.blocker.BlockEventLoop.lambda$start$0(BlockEventLoop.java:11)
	at app//chapter2.blocker.BlockEventLoop$$Lambda$78/0x00000008001a5040.handle(Unknown Source)
	at app//io.vertx.core.impl.VertxImpl$InternalTimerHandler.handle(VertxImpl.java:951)
	at app//io.vertx.core.impl.VertxImpl$InternalTimerHandler.handle(VertxImpl.java:918)
	at app//io.vertx.core.impl.EventLoopContext.emit(EventLoopContext.java:52)
	at app//io.vertx.core.impl.ContextImpl.emit(ContextImpl.java:294)
	at app//io.vertx.core.impl.EventLoopContext.emit(EventLoopContext.java:24)
	at app//io.vertx.core.impl.AbstractContext.emit(AbstractContext.java:49)
	at app//io.vertx.core.impl.EventLoopContext.emit(EventLoopContext.java:24)
	at app//io.vertx.core.impl.VertxImpl$InternalTimerHandler.run(VertxImpl.java:941)
	at app//io.netty.util.concurrent.PromiseTask.runTask(PromiseTask.java:98)
	at app//io.netty.util.concurrent.ScheduledFutureTask.run(ScheduledFutureTask.java:170)
	at app//io.netty.util.concurrent.AbstractEventExecutor.safeExecute(AbstractEventExecutor.java:164)
	at app//io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasks(SingleThreadEventExecutor.java:472)
	at app//io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:500)
	at app//io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:989)
	at app//io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
	at app//io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
	at java.base@11.0.21/java.lang.Thread.run(Thread.java:829)
WARN [vertx-blocked-thread-checker] BlockedThreadChecker - Thread Thread[vert.x-eventloop-thread-0,5,main] has been blocked for 6605 ms, time limit is 2000 ms
io.vertx.core.VertxException: Thread blocked
	at app//chapter2.blocker.BlockEventLoop.lambda$start$0(BlockEventLoop.java:11)
	at app//chapter2.blocker.BlockEventLoop$$Lambda$78/0x00000008001a5040.handle(Unknown Source)
	at app//io.vertx.core.impl.VertxImpl$InternalTimerHandler.handle(VertxImpl.java:951)
	at app//io.vertx.core.impl.VertxImpl$InternalTimerHandler.handle(VertxImpl.java:918)
	at app//io.vertx.core.impl.EventLoopContext.emit(EventLoopContext.java:52)
	at app//io.vertx.core.impl.ContextImpl.emit(ContextImpl.java:294)
	at app//io.vertx.core.impl.EventLoopContext.emit(EventLoopContext.java:24)
	at app//io.vertx.core.impl.AbstractContext.emit(AbstractContext.java:49)
	at app//io.vertx.core.impl.EventLoopContext.emit(EventLoopContext.java:24)
	at app//io.vertx.core.impl.VertxImpl$InternalTimerHandler.run(VertxImpl.java:941)
	at app//io.netty.util.concurrent.PromiseTask.runTask(PromiseTask.java:98)
	at app//io.netty.util.concurrent.ScheduledFutureTask.run(ScheduledFutureTask.java:170)
	at app//io.netty.util.concurrent.AbstractEventExecutor.safeExecute(AbstractEventExecutor.java:164)
	at app//io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasks(SingleThreadEventExecutor.java:472)
	at app//io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:500)
	at app//io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:989)
	at app//io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
	at app//io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
	at java.base@11.0.21/java.lang.Thread.run(Thread.java:829)

当事件处理程序进入阻塞状态后，日志开始输出告警信息，现在开始事件循环线程无法处理其它的事件啦，经过几轮告警（默认设置为5秒）后，就开始打印线程堆栈信息啦，但是需要注意的是，这些只是警告信息，事件循环线程的检查器并不能终止这些阻塞的操作

线程阻塞检查器配置

默认情况，事件循环线程阻塞器发出告警的时间2秒，打印线程堆栈信息的时间是5秒，根据不同设备的处理能力，该时间可以进行灵活的配置

• -Dvertx.options.blockedThreadCheckInterval = 1000 //检查器阈值设置为1秒
• -Dvertx.threadChecks=false //禁用线程阻塞器

生命周期事件异步通知

Verticle中的start和stop方法被称作生命周期方法，该方法在定义时是没有返回值的，根据约定，除非该方法在调用过程中发生了异常，否则则认为该调用是成功的，但是在start和stop方法中可能存在一些异步的操作，那我们如何来监听这些异步操作的成功与失败呢，下面我们就来介绍一下Promise

Vert.x的Promise是对Future-Promise模型的适配，这是一个用于处理异步结果的机制。Promise用来写入异步结果，而Future用来查看异步结果。可调用一个Promise对象的future方法以取得Vert.x中的Future类型的Future对象

package chapter2.future;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;
import io.vertx.core.Promise;
import io.vertx.core.Vertx;

public class FutureVerticle extends AbstractVerticle {

  @Override
  public void start(Promise<Void> promise) {   // Promise的类型是Void，因为Vert.x只关心部署是否成功，不关心带了什么参数
    vertx.createHttpServer()
      .requestHandler(req -> req.response().end("Ok"))
      .listen(8080, ar -> {
        if (ar.succeeded()) {       // 这个listen函数支持异步回调，通过它就知道了结果是成功还是失败
          promise.complete();   // complete函数用于将promise标记为以完成状态，如果Promise的对象类型不是Void，complete函数也可以传递值
        } else {
          promise.fail(ar.cause()); // 如果listen操作失败，将promise标记为失败，并传递一个异常信息
        }
      });
      System.out.println("start执行完成");
  }

  public static void main(String[] args) {
    Vertx vertx = Vertx.vertx();
    //定义一个异步的回调，来监测start方法的执行情况
    vertx.deployVerticle(new FutureVerticle(), h -> {
      if (h.succeeded()) {
        System.out.println("成功");
      } else {
        System.out.println("失败：" + h.cause().getMessage());
      }
    });

  }
}

日常开发中尽量使用有回调参数的异步方法，这样当发生错误的时候，我们就可以得到通知

Verticle配置

应用程序启动的时候经常需要传入不同的配置参数，我们通过Vert.x来部署Verticle的时候也可以进行参数传递和配置，配置数据需要以JSON格式来进行传递，次数使用Vert.x中JsonObject和JsonArray类中的具体API

配置传递示例代码

public class ConfigVerticle extends AbstractVerticle {

  private final Logger logger = LoggerFactory.getLogger(ConfigVerticle.class);

  @Override
  public void start() {
    logger.info("n = {}", config().getInteger("n", -1));
  }

  public static void main(String[] args) {
    Vertx vertx = Vertx.vertx();
    for (int n = 0; n < 4; n++) {
      JsonObject conf = new JsonObject().put("n", n);
      DeploymentOptions opts = new DeploymentOptions() //该对象可以让我们更多的控制部署过程
        .setConfig(conf)
        .setInstances(n); // 该配置表示一次部署了Verticle多个实例
      vertx.deployVerticle("xxx.ConfigVerticle", opts); //当我们一次性部署Verticle多个实例时，该处需要用类的全名；如果是部署单个实例，则可以用全名或者new
    }
  }
}

Verticle部署

上面的示例中，我们通过在Verticle内嵌main方法来完成Verticle的部署，部署都是通过Vert.x对象来进行的，一个由多个Verticle组成的应用程序的典型部署方式是这样的：

• 先部署一个主Verticle
• 主Verticle再部署其它的Verticle
• 被部署的Verticle可以继续部署更多的Verticle

这样的部署方式可能让我们感觉这些Verticle是存在层级关系的，实际上，这些Verticle在运行中不存在父子的概念

部署示例

待部署Verticle

public class BaseVerticle extends AbstractVerticle {

  private final Logger logger = LoggerFactory.getLogger(BaseVerticle.class);

  @Override
  public void start() {
    logger.info("Start");
  }

  @Override
  public void stop() {
    logger.info("Stop");
  }

专门用于部署Verticle的部署工具

public class Deployer extends AbstractVerticle {

  private final Logger logger = LoggerFactory.getLogger(Deployer.class);

  @Override
  public void start() {
    long delay = 1000;
    for (int i = 0; i < 50; i++) {
      vertx.setTimer(delay, id -> deploy());  // 每隔1秒部署一个 BaseVerticle 实例
      delay = delay + 1000;
    }
  }

  private void deploy() {
    vertx.deployVerticle(new BaseVerticle(), ar -> {   // vertx中的Vertcle的部署是一个异步的操作，所以这里使用带异步结果的异步方法来进行部署，部署成功会生成一个唯一的Verticle ID
      if (ar.succeeded()) {
        String id = ar.result();
        logger.info("Successfully deployed {}", id);
        vertx.setTimer(5000, tid -> undeployLater(id));   // Verticle部署成功5秒以后就卸载该实例
      } else {
        logger.error("Error while deploying", ar.cause());
      }
    });
  }

  private void undeployLater(String id) {
    vertx.undeploy(id, ar -> {  //卸载的过程和部署的过程类似，也是一个异步的操作
      if (ar.succeeded()) {
        logger.info("{} was undeployed", id);
      } else {
        logger.error("{} could not be undeployed", id);
      }
    });
  }
}

主启动类

public class Main {

  public static void main(String[] args) {
    Vertx vertx = Vertx.vertx();
    vertx.deployVerticle(new Deployer());
  }
}

该方法也可以直接放在 Deployer 中，放在外面层次更分明一些

线程启动日志分析

通过上面的日志，我们可以得到这样的一些结论：

• 针对于不同的Verticle，并不是有多少个Verticle就会有多少个线程，默认情况下，Vert.x创建的事件循环线程的数量是CPU核心数的2倍，比如说：CPU是4核，那么Vert.x默认会创建8个事件循环线程。Verticle会被轮流分配给各事件循环
• 一个Verticle总是运行在同一个事件循环线程上，而一个事件循环线程会被多个Verticle共享，这种设计使应用程序运行时的线程数量是可以预测的

开发人员可以调整事件循环的数量，但是无法手动指定一个Verticle应该分配到那个事件循环

Vert.x相关笔记

• 异步变成与响应式系统
• 什么是Vert.x

文章来源地址https://www.toymoban.com/news/detail-743428.html

到了这里，关于Vert.x学习笔记-Vert.x的基本处理单元Verticle的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！