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;@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.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 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.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 {@Overridepublic 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);@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 - Start
vert.x-eventloop-thread-0Deployer - Successfully deployed 7186663f-10a6-4cdc-985a-d3357fe240db
vert.x-eventloop-thread-3EmptyVerticle - Start
vert.x-eventloop-thread-0Deployer - Successfully deployed 88ba21cb-e8c1-403b-bf29-edde7c1f2ebc
vert.x-eventloop-thread-4EmptyVerticle - Start
vert.x-eventloop-thread-0Deployer - Successfully deployed e1ccd570-c631-4035-b7d2-7b06bbc3c326
vert.x-eventloop-thread-5EmptyVerticle - Start
vert.x-eventloop-thread-0Deployer - Successfully deployed 8ab2b0f5-856f-498b-8a50-0622a65233cc
vert.x-eventloop-thread-6EmptyVerticle - Start
vert.x-eventloop-thread-0Deployer - Successfully deployed 1191576b-a3c1-49bb-a882-29cdc041a9c2
vert.x-eventloop-thread-7EmptyVerticle - Start
vert.x-eventloop-thread-0Deployer - Successfully deployed 12512cf1-3ad7-41c6-82e0-bd1478524c73
vert.x-eventloop-thread-2EmptyVerticle - Stop
vert.x-eventloop-thread-0Deployer - 7186663f-10a6-4cdc-985a-d3357fe240db was undeployed
vert.x-eventloop-thread-1EmptyVerticle - Start
vert.x-eventloop-thread-0Deployer - Successfully deployed cd6fbb87-10fb-46da-b1c5-710a4d0e305c
vert.x-eventloop-thread-3EmptyVerticle - Stop
vert.x-eventloop-thread-0Deployer - 88ba21cb-e8c1-403b-bf29-edde7c1f2ebc was undeployed
vert.x-eventloop-thread-0EmptyVerticle - Start
vert.x-eventloop-thread-0Deployer - Successfully deployed a574512e-509a-45cb-968c-4ae6c89f7ca2
vert.x-eventloop-thread-2EmptyVerticle - Start

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

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

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

Vert.x相关笔记

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

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/130651.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

使用趋动云部署ChatGLM3-6B模型

使用趋动云部署ChatGLM3-6B模型

使用趋动云部署ChatGLM3-6B模型 1 创建项目2 配置环境 修改代码3 运行代码 1 创建项目 创建项目 进入项目 -> 运行代码 -> 选择资源&#xff08;B1.large&#xff09; 2 配置环境 修改代码 等待开发者工具加载完成 -> 点击 JupyterLab 进入开发环境 打开 termin…
阅读更多...
10.MySQL事务(上)

10.MySQL事务(上)

个人主页&#xff1a;Lei宝啊 愿所有美好如期而遇 目录 前言&#xff1a; 是什么&#xff1f; 为什么? 怎么做&#xff1f; 前言&#xff1a; 本篇文章将会说明什么是事务&#xff0c;为什么会出现事务&#xff1f;事务是怎么做的&#xff1f; 是什么&#xff1f; 我…
阅读更多...
C++二分查找算法的应用：长度递增组的最大数目

C++二分查找算法的应用：长度递增组的最大数目

本文涉及的基础知识点 二分查找 题目 给你一个下标从 0 开始、长度为 n 的数组 usageLimits 。 你的任务是使用从 0 到 n - 1 的数字创建若干组&#xff0c;并确保每个数字 i 在 所有组 中使用的次数总共不超过 usageLimits[i] 次。此外&#xff0c;还必须满足以下条件&…
阅读更多...
【Python实例】netCDF数据介绍及处理

【Python实例】netCDF数据介绍及处理

netCDF数据处理 netCDF数据介绍1 netCDF数据结构1.1 维度(Dimensions)1.2 变量&#xff08;Variables&#xff09;1.3 坐标变量&#xff08;Coordinate Variables)1.4 属性&#xff08;Attributes&#xff09; 2 netCDF数据处理方法1&#xff1a;利用netCDF4打开nc格式数据2.1.…
阅读更多...
华为升腾C92安装windows NAS

华为升腾C92安装windows NAS

华为升腾C92安装windows NAS NAS&#xff08;Network Attached Storage&#xff1a;网络附属存储&#xff09;&#xff0c;我们之前所了解的群晖&#xff0c;也仅仅是NAS当中的一个品牌运营而已。 这次&#xff0c;我决定在C92上面试着安装Windows NAS。虽然群晖NAS是基于Linu…
阅读更多...
OpenCV官方教程中文版 —— 图像去噪

OpenCV官方教程中文版 —— 图像去噪

OpenCV官方教程中文版 —— 图像去噪 前言一、原理二、OpenCV 中的图像去噪1.cv2.fastNlMeansDenoisingColored()2.cv2.fastNlMeansDenoisingMulti() 前言 目标 • 学习使用非局部平均值去噪算法去除图像中的噪音 • 学习函数 cv2.fastNlMeansDenoising()&#xff0c;cv2.fa…
阅读更多...
Breakpad在Windows，Linux双平台编译、集成以及dump文件的分析

Breakpad在Windows，Linux双平台编译、集成以及dump文件的分析

Breakpad在Windows&#xff0c;Linux双平台编译、集成以及dump文件的分析 1、Windows平台 Windows平台上非常好的参考文档&#xff1a; https://r12f.com/posts/google-breakpad-1-introduction-with-windows/ https://r12f.com/posts/google-breakpad-2-implementations-o…
阅读更多...
【大数据】Apache NiFi 数据同步流程实践

【大数据】Apache NiFi 数据同步流程实践

Apache NiFi 数据同步流程实践 1.环境2.Apache NIFI 部署2.1 获取安装包2.2 部署 Apache NIFI 3.NIFI 在手&#xff0c;跟我走&#xff01;3.1 准备表结构和数据3.2 新建一个 Process Group3.3 新建一个 GenerateTableFetch 组件3.4 配置 GenerateTableFetch 组件3.5 配置 DBCP…
阅读更多...
答题测评考试小程序的效果如何

答题测评考试小程序的效果如何

在线答题系统是一种在线练习、考试、测评的智能答题系统&#xff0c;适用于企业培训、测评考试、知识竞赛、模拟考试等场景&#xff0c;管理员可任意组题、随机出题&#xff0c;答题者成功提交后&#xff0c;系统自动判分。 多种题目类型&#xff0c;两种答题模式 练习模式&a…
阅读更多...
Apache Flink 1.12.0 on Yarn(3.1.1) 所遇到的問題

Apache Flink 1.12.0 on Yarn(3.1.1) 所遇到的問題

Apache Flink 1.12.0 on Yarn(3.1.1) 所遇到的問題 新搭建的FLINK集群出现的问题汇总 1.新搭建的Flink集群和Hadoop集群无法正常启动Flink任务 查看这个提交任务的日志无法发现有用的错误信息。 进一步查看yarn日志&#xff1a; 发现只有JobManager的错误日志出现了如下的…
阅读更多...
请求地址‘/operlog‘,发生未知异常

请求地址‘/operlog‘,发生未知异常

&#x1f468;&#x1f3fb;‍&#x1f4bb; 热爱摄影的程序员 &#x1f468;&#x1f3fb;‍&#x1f3a8; 喜欢编码的设计师 &#x1f9d5;&#x1f3fb; 擅长设计的剪辑师 &#x1f9d1;&#x1f3fb;‍&#x1f3eb; 一位高冷无情的编码爱好者 大家好&#xff0c;我是全栈工…
阅读更多...
[nodejs] 爬虫加入并发限制并发实现痞客邦网页截图

[nodejs] 爬虫加入并发限制并发实现痞客邦网页截图

今晚想给偶像的相册截个图,避免某一天网站挂了我想看看回忆都不行,用的是js的木偶师来爬虫台湾的部落格,效果图大概是这样,很不错 问题来了.我很贪心, 我想一次性把相册全爬了,也就是并发 ,这个人的相册有19个!!我一下子要开19个谷歌浏览器那个什么进程, 然后程序就崩了, 我就想…
阅读更多...
软件设计模式原则（二）开闭原则

软件设计模式原则（二）开闭原则

继续讲解第二个重要的设计模式原则——开闭原则~ 一.定义 开闭原则&#xff0c;在面向对象编程领域中&#xff0c;规定“软件中的对象&#xff08;类&#xff0c;模块&#xff0c;函数等等&#xff09;应该对于扩展是开放的&#xff0c;但是对于修改是封闭的”&#xff0c;这意…
阅读更多...
半导体芯片制造行业MES系统解决方案

半导体芯片制造行业MES系统解决方案

半导体产业作为现代电子科技的重要支柱&#xff0c;驱动着电子设备和通信技术的飞速发展。随着技术不断演进&#xff0c;半导体制造企业面临着越来越多的挑战&#xff0c;如高度复杂的工艺流程、全球化的竞争、质量控制的要求以及能源效率等问题。 为了应对这些挑战&#xff0…
阅读更多...
Python测试之Pytest详解

Python测试之Pytest详解

概要 当涉及到python的测试框架时&#xff0c;pytest是一个功能强大且广泛应用的第三方库。它提供简洁而灵活的方式来编写和执行测试用例&#xff0c;并具有广泛的应用场景。下面是pytest的介绍和详细使用说明&#xff1a; pytest是一个用于python单元测试的框架&#xff0c;它…
阅读更多...
Dubbo篇---第一篇

Dubbo篇---第一篇

系列文章目录 文章目录 系列文章目录一、说说一次 Dubbo 服务请求流程？二、说说 Dubbo 工作原理三、Dubbo 支持哪些协议？一、说说一次 Dubbo 服务请求流程？ 基本工作流程： 上图中角色说明： 二、说说 Dubbo 工作原理 工作原理分 10 层： 第一层：service 层，接口层，…
阅读更多...
Flutter 05 组件状态、生命周期、数据传递（共享）、Key

Flutter 05 组件状态、生命周期、数据传递（共享）、Key

一、Android界面渲染流程UI树与FlutterUI树的设计思路对比 二、Widget组件生命周期详解 1、Widget组件生命周期 和其他的视图框架比如android的Activity一样&#xff0c;flutter中的视图Widget也存在生命周期&#xff0c;生命周期的回调函数体现在了State上面。组件State的生命…
阅读更多...
mysql索引深度学习

mysql索引深度学习

索引是什么&#xff1f; 索引是一种用于加快查询和索引的数据结构&#xff0c;其本质上就是一种排序好的数据结构&#xff0c;就类似书的目录。 索引的底层有多种实现的结构&#xff1a;b树&#xff0c;b树&#xff0c;Hash&#xff0c;红黑树。InnoDB和MyISAM的索引都是通过…
阅读更多...
Python模块psutil：系统进程管理与Selenium效率提升的完美结合

Python模块psutil：系统进程管理与Selenium效率提升的完美结合

前言 在前面编写一个Selenium的自动化程序时候&#xff0c;发现一个问题。 因笔记本配置较为差&#xff0c;所以每次初始化Selenium的WebDriver都会非常慢&#xff0c;整个等待过程是不友好的。 所以我就想到&#xff1a; 在程序中初始化一个全局的WebDriver对象&#xff0c…
阅读更多...
算法——多数相和

算法——多数相和

三数 15. 三数之和 - 力扣&#xff08;LeetCode&#xff09; 所以代码实现应该是 vector<vector<int>> threeSum(vector<int>& nums) {int n nums.size();sort(nums.begin(), nums.end()); // 对数组进行排序&#xff0c;以便后续操作vector<vector…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023