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

2023-11-05 07:20
文章标签 学习 笔记 基本 vert verticle 处理单元

本文主要是介绍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

在这里插入图片描述

这篇关于Vert.x学习笔记-Vert.x的基本处理单元Verticle的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/348301。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...
学习hash总结

学习hash总结

2014/1/29/   最近刚开始学hash，名字很陌生，但是hash的思想却很熟悉，以前早就做过此类的题，但是不知道这就是hash思想而已，说白了hash就是一个映射，往往灵活利用数组的下标来实现算法，hash的作用：1、判重；2、统计次数；
阅读更多...
基本知识点

基本知识点

1、c++的输入加上ios::sync_with_stdio(false);  等价于 c的输入，读取速度会加快（但是在字符串的题里面和容易出现问题） 2、lower_bound()和upper_bound() iterator lower_bound( const key_type &key ): 返回一个迭代器，指向键值>= key的第一个元素。 iterator upper_bou
阅读更多...
零基础学习Redis(10) -- zset类型命令使用

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合，内部除了存储元素外，还会存储一个score，存储在zset中的元素会按照score的大小升序排列，不同元素的score可以重复，score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]
阅读更多...
【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程（Gaussian Process，简称GP）是一种概率模型，用于描述一组随机变量的联合概率分布，其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数（或核函数） 1.3 核函数1.4 高斯过程回归（Gauss
阅读更多...
【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

系列文章目录 监督学习：参数方法 【学习笔记】 陈强-机器学习-Python-Ch4 线性回归 【学习笔记】 陈强-机器学习-Python-Ch5 逻辑回归 【课后题练习】 陈强-机器学习-Python-Ch5 逻辑回归（SAheart.csv） 【学习笔记】 陈强-机器学习-Python-Ch6 多项逻辑回归 【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch7 判别分析 【学
阅读更多...
【IPV6从入门到起飞】5-1 IPV6+Home Assistant(搭建基本环境)

【IPV6从入门到起飞】5-1 IPV6+Home Assistant(搭建基本环境)

【IPV6从入门到起飞】5-1 IPV6+Home Assistant #搭建基本环境 1 背景2 docker下载 hass3 创建容器4 浏览器访问 hass5 手机APP远程访问hass6 更多玩法 1 背景 既然电脑可以IPV6入站，手机流量可以访问IPV6网络的服务，为什么不在电脑搭建Home Assistant（hass），来控制你的设备呢？@智能家居 @万物互联
阅读更多...
系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

本章知识考点：         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2