青岛网站建设推进,wordpress导购页面,做网站有多砸钱,专业的网上购物平台Verticle介绍
Verticle是Vert.x的基本处理单元#xff0c;Vert.x应用程序中存在着处理各种事件的处理单元#xff0c;比如负责HTTP API响应请求的处理单元、负责数据库存取的处理单元、负责向第三方发送请求的处理单元。Verticle就是对这些功能单元的封装#xff0c;Vertic…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(PromiseVoid 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(PromiseVoid 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;Overridepublic 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();//部署一个Verticlevertx.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 {Overridepublic 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 blockedat 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.base11.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 blockedat 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.base11.0.21/java.lang.Thread.run(Thread.java:829)当事件处理程序进入阻塞状态后日志开始输出告警信息现在开始事件循环线程无法处理其它的事件啦经过几轮告警默认设置为5秒后就开始打印线程堆栈信息啦但是需要注意的是这些只是警告信息事件循环线程的检查器并不能终止这些阻塞的操作 线程阻塞检查器配置
默认情况事件循环线程阻塞器发出告警的时间2秒打印线程堆栈信息的时间是5秒根据不同设备的处理能力该时间可以进行灵活的配置
-Dvertx.options.blockedThreadCheckInterval 1000 //检查器阈值设置为1秒-Dvertx.threadChecksfalse //禁用线程阻塞器
生命周期事件异步通知
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 {Overridepublic void start(PromiseVoid 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的对象类型不是Voidcomplete函数也可以传递值} 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);Overridepublic 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);Overridepublic void start() {logger.info(Start);}Overridepublic void stop() {logger.info(Stop);}专门用于部署Verticle的部署工具
public class Deployer extends AbstractVerticle {private final Logger logger LoggerFactory.getLogger(Deployer.class);Overridepublic 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 IDif (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 中放在外面层次更分明一些 线程启动日志分析
线程ID操作行为vert.x-eventloop-thread-2EmptyVerticle - Startvert.x-eventloop-thread-0Deployer - Successfully deployed 7186663f-10a6-4cdc-985a-d3357fe240dbvert.x-eventloop-thread-3EmptyVerticle - Startvert.x-eventloop-thread-0Deployer - Successfully deployed 88ba21cb-e8c1-403b-bf29-edde7c1f2ebcvert.x-eventloop-thread-4EmptyVerticle - Startvert.x-eventloop-thread-0Deployer - Successfully deployed e1ccd570-c631-4035-b7d2-7b06bbc3c326vert.x-eventloop-thread-5EmptyVerticle - Startvert.x-eventloop-thread-0Deployer - Successfully deployed 8ab2b0f5-856f-498b-8a50-0622a65233ccvert.x-eventloop-thread-6EmptyVerticle - Startvert.x-eventloop-thread-0Deployer - Successfully deployed 1191576b-a3c1-49bb-a882-29cdc041a9c2vert.x-eventloop-thread-7EmptyVerticle - Startvert.x-eventloop-thread-0Deployer - Successfully deployed 12512cf1-3ad7-41c6-82e0-bd1478524c73vert.x-eventloop-thread-2EmptyVerticle - Stopvert.x-eventloop-thread-0Deployer - 7186663f-10a6-4cdc-985a-d3357fe240db was undeployedvert.x-eventloop-thread-1EmptyVerticle - Startvert.x-eventloop-thread-0Deployer - Successfully deployed cd6fbb87-10fb-46da-b1c5-710a4d0e305cvert.x-eventloop-thread-3EmptyVerticle - Stopvert.x-eventloop-thread-0Deployer - 88ba21cb-e8c1-403b-bf29-edde7c1f2ebc was undeployedvert.x-eventloop-thread-0EmptyVerticle - Startvert.x-eventloop-thread-0Deployer - Successfully deployed a574512e-509a-45cb-968c-4ae6c89f7ca2vert.x-eventloop-thread-2EmptyVerticle - Start
通过上面的日志我们可以得到这样的一些结论
针对于不同的Verticle并不是有多少个Verticle就会有多少个线程默认情况下Vert.x创建的事件循环线程的数量是CPU核心数的2倍比如说CPU是4核那么Vert.x默认会创建8个事件循环线程。Verticle会被轮流分配给各事件循环一个Verticle总是运行在同一个事件循环线程上而一个事件循环线程会被多个Verticle共享这种设计使应用程序运行时的线程数量是可以预测的 开发人员可以调整事件循环的数量但是无法手动指定一个Verticle应该分配到那个事件循环 Vert.x相关笔记
异步变成与响应式系统什么是Vert.x
