【Spark源码分析】Spark的RPC通信二-初稿

Spark的RPC通信二-初稿

Spark RPC的传输层

传输层主要还是借助netty框架进行实现。

TransportContext包含创建 TransportServer、TransportClientFactory 和使用 TransportChannelHandler 设置 Netty Channel 管道的上下文。TransportClient 提供两种通信协议：control-plane RPCs 和data-plane的 “chunk fetching”。RPC 的处理在 TransportContext 的范围之外进行（即由用户提供的处理程序执行），它负责设置流，这些流可以使用零拷贝 IO 以块为单位通过数据平面进行流式传输。对消息的处理由RpcHandler处理。TransportServer 和 TransportClientFactory 都会为每个通道创建一个 TransportChannelHandler。由于每个 TransportChannelHandler 都包含一个 TransportClient，因此服务器进程可以通过现有通道向客户端发送消息。
TransportContext
-TransportConf conf
-RpcHandler rpcHandler
-boolean closeIdleConnections
-boolean isClientOnly
-MessageEncoder ENCODER
-MessageEncoder DECODER
-EventLoopGroup chunkFetchWorkers
+TransportClientFactory createClientFactory()
+TransportServer createServer()
+TransportChannelHandler createChannelHandler()
+TransportChannelHandler initializePipeline()
ClientPool
TransportClient[] clients
Object[] lock
TransportClientFactory
-TransportContext context
-TransportConf conf
-List clientBootstraps
-ConcurrentHashMap connectionPool
-int numConnectionsPerPeer
-final Class socketChannelClass
-EventLoopGroup workerGroup
-PooledByteBufAllocator pooledAllocator
-NettyMemoryMetrics metrics
«interface»
TransportClientBootstrap
void doBootstrap(TransportClient client, Channel channel)
«interface»
TransportServerBootstrap
RpcHandler doBootstrap(Channel channel, RpcHandler rpcHandler)
«abstract»
MessageHandler
abstract void handle(T message)
abstract void channelActive()
abstract void exceptionCaught(Throwable cause)
abstract void channelInactive()
«interface»
Message
«abstract»
RpcHandler
TransportRequestHandler
RpcHandler rpcHandler
StreamManager streamManager
TransportResponseHandler
TransportClient
TransportServer
TransportChannelHandler

传输上下文TransportContext

TransportContext的核心成员与核心方法

  • TransportConf conf：传输的配置信息
  • RpcHandler rpcHandler：对接收的RPC消息进行处理
  • EventLoopGroup chunkFetchWorkers：处理 ChunkFetchRequest 的独立线程池。这有助于控制通过底层通道将 ChunkFetchRequest 信息写回客户端时阻塞的 TransportServer 工作线程的最大数量。
  • createClientFactory()：初始化 ClientFactory，在返回新客户端之前运行给定的 TransportClientBootstraps。Bootstraps 将同步执行，并且必须成功运行才能创建客户端。
  • createServer()：创建传输服务端TransportServer的实例
  • initializePipeline()：对TransportClient，TransportRequestHandler，TransportResponseHandler进行初始化，然后在用其构造TransportChannelHandler对象。借助Netty的API对管道进行配置。

TransportContext的createClientFactory方法创建传输客户端工厂TransportClientFactory的实例。在构造TransportClientFactory的实例时，还会传递客户端引导程序TransportClientBootstrap的列表。TransportClientFactory内部维护每个Socket地址的连接池。通过调用TransportContext的createServer方法创建传输服务端TransportServer的实例。

核心类TransportClientFactory

用于使用 createClient方法 创建 TransportClients 的工厂。该工厂负责维护与其他主机的连接池，并为同一远程主机返回相同的 TransportClient。它还为所有 TransportClients 共享一个工作线程池。只要有可能，就会重复使用 TransportClients。在完成创建新的 TransportClient 之前，将运行所有给定的 TransportClientBootstraps。

TransportClientFactory的核心成员和核心方法

  • 静态内部类ClientPool：一种简单的数据结构，用于跟踪两个对等节点之间的客户端连接池，保障其可以复用，由于线程不安全，所以增加了客户端对应的锁。

      private static class ClientPool {TransportClient[] clients;Object[] locks;ClientPool(int size) {clients = new TransportClient[size];locks = new Object[size];for (int i = 0; i < size; i++) {locks[i] = new Object();}}}

  • TransportContext context：TransportContext 的实例对象

  • TransportConf conf：链接配置信息的实例对象

  • List<TransportClientBootstrap> clientBootstraps：客户端的引导程序，主要是客户端在建立连接的时候，进行一些初始化的准备操作。

  • ConcurrentHashMap<SocketAddress, ClientPool> connectionPool：维护了连接地址上的客户端连接池的映射表。

  • createClient(String remoteHost, int remotePort)：

    • 首先根据远程地址，确认客户端连接池connectionPool中是否存在关于这个地址的客户端池clientPool，如果没有就新建一个客户端池放入连接池中。
    • 检查通道是否超时和客户端是否存活，如果客户端失活，则需要重建一个客户端。创建客户端的在createClient(InetSocketAddress address)方法中。
      public TransportClient createClient(String remoteHost, int remotePort)throws IOException, InterruptedException {// 此处使用未解析地址，以避免每次创建客户端时都进行 DNS 解析。final InetSocketAddress unresolvedAddress =InetSocketAddress.createUnresolved(remoteHost, remotePort);// 如果clientPool不存在，则新建.ClientPool clientPool = connectionPool.get(unresolvedAddress);if (clientPool == null) {connectionPool.putIfAbsent(unresolvedAddress, new ClientPool(numConnectionsPerPeer));clientPool = connectionPool.get(unresolvedAddress);}int clientIndex = rand.nextInt(numConnectionsPerPeer);TransportClient cachedClient = clientPool.clients[clientIndex];if (cachedClient != null && cachedClient.isActive()) {// 更新处理程序的最后使用时间，确保通道不会超时TransportChannelHandler handler = cachedClient.getChannel().pipeline().get(TransportChannelHandler.class);synchronized (handler) {handler.getResponseHandler().updateTimeOfLastRequest();}// 然后检查客户端是否还活着，以防在代码更新之前超时。if (cachedClient.isActive()) {logger.trace("Returning cached connection to {}: {}",cachedClient.getSocketAddress(), cachedClient);return cachedClient;}}// 如果我们到达这里，就没有打开现有连接，尝试创建一个新连接。final long preResolveHost = System.nanoTime();final InetSocketAddress resolvedAddress = new InetSocketAddress(remoteHost, remotePort);final long hostResolveTimeMs = (System.nanoTime() - preResolveHost) / 1000000;if (hostResolveTimeMs > 2000) {logger.warn("DNS resolution for {} took {} ms", resolvedAddress, hostResolveTimeMs);} else {logger.trace("DNS resolution for {} took {} ms", resolvedAddress, hostResolveTimeMs);}// 多个线程可能会竞相在这里创建新连接。通过同步原语只保留其中一个处于活动状态。synchronized (clientPool.locks[clientIndex]) {cachedClient = clientPool.clients[clientIndex];if (cachedClient != null) {if (cachedClient.isActive()) {logger.trace("Returning cached connection to {}: {}", resolvedAddress, cachedClient);return cachedClient;} else {logger.info("Found inactive connection to {}, creating a new one.", resolvedAddress);}}clientPool.clients[clientIndex] = createClient(resolvedAddress);return clientPool.clients[clientIndex];}}

  • createClient(InetSocketAddress address)：

    • 通过Netty的根引导程序进行初始化配置
    • 通过回调函数初始化bootstrap的Pipeline，设置好客户端引用和管道引用。
    • 遍历客户端引导程序集clientBootstraps，执行其初始化的内容
      private TransportClient createClient(InetSocketAddress address)throws IOException, InterruptedException {logger.debug("Creating new connection to {}", address);// netty的连接创建的根引导程序Bootstrap bootstrap = new Bootstrap();bootstrap.group(workerGroup).channel(socketChannelClass)// 禁用纳格尔算法，因为我们不想让数据包等待.option(ChannelOption.TCP_NODELAY, true).option(ChannelOption.SO_KEEPALIVE, true).option(ChannelOption.CONNECT_TIMEOUT_MILLIS, conf.connectionTimeoutMs()).option(ChannelOption.ALLOCATOR, pooledAllocator);if (conf.receiveBuf() > 0) {bootstrap.option(ChannelOption.SO_RCVBUF, conf.receiveBuf());}if (conf.sendBuf() > 0) {bootstrap.option(ChannelOption.SO_SNDBUF, conf.sendBuf());}final AtomicReference<TransportClient> clientRef = new AtomicReference<>();final AtomicReference<Channel> channelRef = new AtomicReference<>();// 通过回调函数初始化bootstrap的Pipelinebootstrap.handler(new ChannelInitializer<SocketChannel>() {@Overridepublic void initChannel(SocketChannel ch) {TransportChannelHandler clientHandler = context.initializePipeline(ch);clientRef.set(clientHandler.getClient());channelRef.set(ch);}});// 连接远程服务器long preConnect = System.nanoTime();ChannelFuture cf = bootstrap.connect(address);if (!cf.await(conf.connectionTimeoutMs())) {throw new IOException(String.format("Connecting to %s timed out (%s ms)", address, conf.connectionTimeoutMs()));} else if (cf.cause() != null) {throw new IOException(String.format("Failed to connect to %s", address), cf.cause());}TransportClient client = clientRef.get();Channel channel = channelRef.get();assert client != null : "Channel future completed successfully with null client";// 在将客户端标记为成功之前，同步执行任何客户端引导。long preBootstrap = System.nanoTime();logger.debug("Connection to {} successful, running bootstraps...", address);try {// 遍历客户端引导程序集clientBootstraps，执行其初始化的内容for (TransportClientBootstrap clientBootstrap : clientBootstraps) {clientBootstrap.doBootstrap(client, channel);}} catch (Exception e) { // catch non-RuntimeExceptions too as bootstrap may be written in Scalalong bootstrapTimeMs = (System.nanoTime() - preBootstrap) / 1000000;logger.error("Exception while bootstrapping client after " + bootstrapTimeMs + " ms", e);client.close();throw Throwables.propagate(e);}long postBootstrap = System.nanoTime();logger.info("Successfully created connection to {} after {} ms ({} ms spent in bootstraps)",address, (postBootstrap - preConnect) / 1000000, (postBootstrap - preBootstrap) / 1000000);return client;}

TransportClient

用于向server端发送rpc请求和从server 端获取流的chunk块，旨在高效传输大量数据，这些数据被分成大小从几百 KB 到几 MB 不等的数据块。

典型流程

// 打开远程文件
client.sendRPC(new OpenFile("/foo")) --> returns StreamId = 100
// 获取远程文件的chunk
client.fetchChunk(streamId = 100, chunkIndex = 0, callback)
client.fetchChunk(streamId = 100, chunkIndex = 1, callback)
// 关闭远程文件
client.sendRPC(new CloseStream(100))

用于获取预协商数据流中连续数据块的客户端，处理的是从数据流（即数据平面）中获取数据块的过程，但数据流的实际设置是在传输层范围之外完成的。提供 "sendRPC "方便方法是为了在客户端和服务器之间进行控制平面通信，以执行此设置。使用 TransportClientFactory 构建一个 TransportClient 实例。单个 TransportClient 可用于多个流，但任何给定的流都必须仅限于单个客户端，以避免响应顺序混乱。注意：该类用于向服务器发出请求，而 TransportResponseHandler 则负责处理来自服务器的响应。并发性：线程安全，可由多个线程调用。

TransportServer

服务器，提供高效的底层流媒体服务。

消息的处理

消息处理类MessageHandler处理来自 Netty 的请求或响应信息。一个 MessageHandler 实例只与一个Netty通道相关联（尽管同一通道上可能有多个客户端）。以下是其定义的抽象方法。

  • abstract void handle(T message)：对接收的单条信息的处理。
  • abstract void channelActive()：当该消息处理程序所在的频道处于活动状态时调用。
  • abstract void exceptionCaught(Throwable cause)：当通道上出现异常时调用。
  • abstract void channelInactive()：当此 MessageHandler 所处的通道处于非活动状态时调用。

MessageHandler有两个继承类TransportRequestHandler和TransportResponseHandler分别用来进行Server端处理Client的请求信息和Client端处理Server的响应信息。

TransportRequestHandler的handle(RequestMessage request)方法

  public void handle(RequestMessage request) {if (request instanceof RpcRequest) {// 处理RPC请求，依赖RpcHandler的receive()方法processRpcRequest((RpcRequest) request);} else if (request instanceof OneWayMessage) {// 处理无需回复的RPC请求，依赖RpcHandler的receive()方法processOneWayMessage((OneWayMessage) request);} else if (request instanceof StreamRequest) {// 处理流请求，依赖StreamManager的openStream()方法获取流数据并封装成ManagedBufferprocessStreamRequest((StreamRequest) request);} else {// 未知请求抛异常throw new IllegalArgumentException("Unknown request type: " + request);}}

TransportResponseHandler的handle(ResponseMessage message)方法

在client端发送消息时，根据发送消息的类型调用TransportResponseHandler中的方法注册回调函数，回调函数和请求信息放入相应的缓存中。

待TransportResponseHandler收到server端的响应消息时，再调用主要的工作方法handle()，根据响应消息类型从对应缓存中取出回调函数并调用。

  @Overridepublic void handle(ResponseMessage message) throws Exception {if (message instanceof ChunkFetchSuccess) {ChunkFetchSuccess resp = (ChunkFetchSuccess) message;ChunkReceivedCallback listener = outstandingFetches.get(resp.streamChunkId);if (listener == null) {logger.warn("Ignoring response for block {} from {} since it is not outstanding",resp.streamChunkId, getRemoteAddress(channel));resp.body().release();} else {outstandingFetches.remove(resp.streamChunkId);listener.onSuccess(resp.streamChunkId.chunkIndex, resp.body());resp.body().release();}} else if (message instanceof ChunkFetchFailure) {ChunkFetchFailure resp = (ChunkFetchFailure) message;ChunkReceivedCallback listener = outstandingFetches.get(resp.streamChunkId);if (listener == null) {logger.warn("Ignoring response for block {} from {} ({}) since it is not outstanding",resp.streamChunkId, getRemoteAddress(channel), resp.errorString);} else {outstandingFetches.remove(resp.streamChunkId);listener.onFailure(resp.streamChunkId.chunkIndex, new ChunkFetchFailureException("Failure while fetching " + resp.streamChunkId + ": " + resp.errorString));}} else if (message instanceof RpcResponse) {RpcResponse resp = (RpcResponse) message;RpcResponseCallback listener = outstandingRpcs.get(resp.requestId);if (listener == null) {logger.warn("Ignoring response for RPC {} from {} ({} bytes) since it is not outstanding",resp.requestId, getRemoteAddress(channel), resp.body().size());} else {outstandingRpcs.remove(resp.requestId);try {listener.onSuccess(resp.body().nioByteBuffer());} finally {resp.body().release();}}} else if (message instanceof RpcFailure) {RpcFailure resp = (RpcFailure) message;RpcResponseCallback listener = outstandingRpcs.get(resp.requestId);if (listener == null) {logger.warn("Ignoring response for RPC {} from {} ({}) since it is not outstanding",resp.requestId, getRemoteAddress(channel), resp.errorString);} else {outstandingRpcs.remove(resp.requestId);listener.onFailure(new RuntimeException(resp.errorString));}} else if (message instanceof StreamResponse) {StreamResponse resp = (StreamResponse) message;Pair<String, StreamCallback> entry = streamCallbacks.poll();if (entry != null) {StreamCallback callback = entry.getValue();if (resp.byteCount > 0) {StreamInterceptor interceptor = new StreamInterceptor(this, resp.streamId, resp.byteCount,callback);try {TransportFrameDecoder frameDecoder = (TransportFrameDecoder)channel.pipeline().get(TransportFrameDecoder.HANDLER_NAME);frameDecoder.setInterceptor(interceptor);streamActive = true;} catch (Exception e) {logger.error("Error installing stream handler.", e);deactivateStream();}} else {try {callback.onComplete(resp.streamId);} catch (Exception e) {logger.warn("Error in stream handler onComplete().", e);}}} else {logger.error("Could not find callback for StreamResponse.");}} else if (message instanceof StreamFailure) {StreamFailure resp = (StreamFailure) message;Pair<String, StreamCallback> entry = streamCallbacks.poll();if (entry != null) {StreamCallback callback = entry.getValue();try {callback.onFailure(resp.streamId, new RuntimeException(resp.error));} catch (IOException ioe) {logger.warn("Error in stream failure handler.", ioe);}} else {logger.warn("Stream failure with unknown callback: {}", resp.error);}} else {throw new IllegalStateException("Unknown response type: " + message.type());}}

消息的分类

MessageHandler用来处理的消息都是继承或实现自Message接口的。
«interface»
Message
«interface»
RequestMessage
«interface»
ResponseMessage
«abstract»
AbstractMessage
«abstract»
AbstractResponseMessage
MessageHandler
abstract void handle(T message)
ChunkFetchRequest
OneWayMessage
RpcRequest
StreamRequest
ChunkFetchFailure
RpcFailure
StreamFailure
ChunkFetchSuccess
RpcResponse
StreamResponse

根据上面的类图可以看出，主要分类

  • AbstractMessage：抽象类，用于在单独的缓冲区中保存正文。其他消息类基本都继承该类。

  • RequestMessage：定义了从客户端到服务端的消息接口

    • ChunkFetchRequest：请求获取数据流中单个数据块的序列。这将对应一个响应信息（成功或失败）。
    • RpcRequest：由远程服务端 org.apache.spark.network.server.RpcHandler 处理的通用 RPC。这将对应一个响应信息（成功或失败）。
    • OneWayMessage：由远程服务端 org.apache.spark.network.server.RpcHandler 处理。不需要进行回复客户端。
    • StreamRequest：请求从远端流式传输数据。数据流 ID 是一个任意字符串，需要两个端点协商后才能流式传输数据

  • ResponseMessage：定义了从服务端到客户端的消息接口

    • AbstractResponseMessage：响应信息的抽象类。
      • ChunkFetchSuccess：处理ChunkFetchRequest成功后返回的消息。
      • RpcResponse：处理RpcRequest成功后返回的消息。
      • StreamResponse：处理StreamRequest成功后返回的消息。
    • ChunkFetchFailure：处理ChunkFetchRequest失败后返回的消息。
    • RpcFailure：处理RpcRequest失败后返回的消息。
    • StreamFailure：处理StreamRequest失败后返回的消息。

client端请求和响应的流程

传输层
1.addRpcRequest或addFetchRequest
2.WriteAndFlush
IdleStateHandler
MessageDecoder
TransportFrameDecoder
TransportResponseHandler
TransportChannelHandler
Netty
MessageEncoder
TransportClient
Request
Response

server端处理请求和响应的流程

传输层
IdleStateHandler
MessageDecoder
TransportFrameDecoder
TransportRequestHandler
TransportChannelHandler
StreamManager
RpcHandler
Netty
MessageEncoder
Request
Response

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

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

相关文章

蓝桥杯-每日刷题-024

蓝桥杯-每日刷题-024

一个星期有七天 一、问题要求 题目描述 为了学英语&#xff0c;小聪做了很多卡片。其中有七张卡片&#xff0c;一面是数字1、2、3、4、5、6、7&#xff0c;另一面分别是monday、tuesday、wednesday、thursday、friday、saturday、sunday.请你对任意的数字&#xff0c;输出相应…
阅读更多...
Layui 下拉select多选实现

Layui 下拉select多选实现

1. html <div id"mo_deptment"></div> 2.引用 <script src"~/layuiadmin/layui/xm-select.js"></script>3.设置全局变量存储控件 var mo_deptmentSelect; 4.layui.use 中初始化 4.1 列表数据 var mo_deptmentdata [ …
阅读更多...
红队打靶练习:DIGITALWORLD.LOCAL: DEVELOPMENT

红队打靶练习:DIGITALWORLD.LOCAL: DEVELOPMENT

信息收集 1、arp ┌──(root㉿ru)-[~/kali] └─# arp-scan -l Interface: eth0, type: EN10MB, MAC: 00:0c:29:69:c7:bf, IPv4: 192.168.12.128 Starting arp-scan 1.10.0 with 256 hosts (https://github.com/royhills/arp-scan) 192.168.12.1 00:50:56:c0:00:08 …
阅读更多...
数字图像处理-空间域图像增强-爆肝18小时用通俗语言进行超详细的总结

数字图像处理-空间域图像增强-爆肝18小时用通俗语言进行超详细的总结

目录 灰度变换 直方图&#xff08;Histogram&#xff09; 直方图均衡 直方图匹配&#xff08;规定化&#xff09; 空间滤波 低通滤波器 高通滤波器 ​​​​​​​ 本文章讲解数字图像处理空间域图像增强&#xff0c;大部分内容来源于课堂笔记中 灰度变换 图像增强&…
阅读更多...
MyBatis的延迟加载（懒加载）

MyBatis的延迟加载（懒加载）

MyBatis 中的延迟加载是指在需要时才加载对象的某些属性或关联对象&#xff0c;而不是在初始查询时就加载所有数据。这对于性能优化和减少不必要的数据库查询非常有用。 1. 基于配置文件的延迟加载 在 MyBatis 的 XML 映射文件中&#xff0c;你可以使用 lazyLoadingEnabled 和…
阅读更多...
使用Python将OSS文件免费下载到本地：第一步 列举OSS文件

使用Python将OSS文件免费下载到本地：第一步 列举OSS文件

大家好，我是水滴~~ 本文将介绍了使用的知识点、以及列举OSS文件的代码、并对该代码进行详细解析、最后给出部署方案，希望能对你有所帮助！ 《Python入门核心技术》专栏总目录・点这里 系列文章 使用Python将OSS文件免费下载到本地：项目分析和准备工作使用Python将OSS文件免…
阅读更多...
【网络安全】学习Web安全必须知道的一本书

【网络安全】学习Web安全必须知道的一本书

【文末送书】今天推荐一本网络安全领域优质书籍。 目录 正文实战案例1&#xff1a;使用Docker搭建LAMP环境实战案例2&#xff1a;使用Docker搭建LAMP环境文末送书 正文 学习Web安全离不开Web&#xff0c;那么&#xff0c;需要先来学习网站的搭建。搭建网站是每一个Web安全学习…
阅读更多...
为什么SSL证书是必备之物？

为什么SSL证书是必备之物？

SSL证书的首要任务是保障用户和网站之间的数据传输安全。未加密的数据传输容易受到中间人攻击&#xff0c;使敏感信息暴露于风险之中。SSL通过加密数据&#xff0c;有效地抵御了这些潜在的威胁&#xff0c;确保用户的隐私得到充分保护。 采用SSL证书的网站在浏览器地址栏中通常…
阅读更多...
如何进行USB丢弃攻击？

如何进行USB丢弃攻击？

USB丢弃攻击&#xff0c;类似于一场表演艺术&#xff0c;您需要构建一个引人入胜的故事&#xff0c;激发目标的好奇心&#xff0c;让他们忽略基本的安全意识&#xff0c;插入您精心准备的USB设备! 本文章仅限娱乐&#xff0c;请勿模仿或进行违法活动&#xff01; 一、选择放置…
阅读更多...
Java版企业电子招投标系统源代码，支持二次开发，采用Spring cloud微服务架构

Java版企业电子招投标系统源代码，支持二次开发，采用Spring cloud微服务架构

招投标管理系统是一个集门户管理、立项管理、采购项目管理、采购公告管理、考核管理、报表管理、评审管理、企业管理、采购管理和系统管理于一体的综合性应用平台。它适用于招标代理、政府采购、企业采购和工程交易等业务的企业&#xff0c;旨在提高项目管理的效率和质量。该系…
阅读更多...
Http---HTTP响应报文

Http---HTTP响应报文

1. HTTP响应报文分析 HTTP 响应报文效果图: 响应报文说明: --- 响应行/状态行 --- HTTP/1.1 200 OK # HTTP协议版本 状态码 状态描述 --- 响应头 --- Server: Tengine # 服务器名称 Content-Type: text/html; charsetUTF-8 # 内容类型 Transfer-Encoding: chunked # 发送给客…
阅读更多...
【Qt之Quick模块】5. QML基本类型及示例用法

【Qt之Quick模块】5. QML基本类型及示例用法

QML格式 QML基本类型 在 QML 中&#xff0c;有以下基本类型&#xff1a; int&#xff1a;整数类型。 Rectangle {function myFunction() {// 输出 debug 信息console.log("11 " (11));}Component.onCompleted: {myFunction();} }结果&#xff1a; 2. real&…
阅读更多...
FreeRTOS之队列集操作（实践）

FreeRTOS之队列集操作（实践）

多个任务在在同一队列中传递的同一种数据类型&#xff0c;而队列集能够在任务之间传递不同的数据类型。 配置流程&#xff1a;&#xff08;更详细流程参考正点原子的教程&#xff09; 1、启用队列集将configUSE_QUEUE_SETA置1&#xff09; 2、创建队列集 3、创建队列或信号…
阅读更多...
EDA设计基础练习题

EDA设计基础练习题

EDA设计基础练习题 &#xff1a; 1、设计一个三输入或非门电路。 2、三输入三输出电路设计&#xff1a; 输入A为1时&#xff0c;对应输出为1&#xff0c;A为0时&#xff0c;输出为0&#xff1b; 输入B为1时&#xff0c;对应输出为0&#xff0c;B为0时&#xff0c;输出为1&am…
阅读更多...
SpringBoot对接支付宝完成扫码支付

SpringBoot对接支付宝完成扫码支付

文章目录 1、支付方式选择2、交互流程3、对接准备1&#xff09;加密解密 签名验签2&#xff09;沙箱环境3&#xff09;内网穿透 4、二维码5、下单6、异步通知回调7、查询支付结果8、退款9、通用版SDK 需求&#xff1a;系统A对接支付宝&#xff0c;实现支持用户扫码支付 1、支…
阅读更多...
成为一名FPGA工程师：面试题与经验分享

成为一名FPGA工程师：面试题与经验分享

在现代科技领域&#xff0c;随着数字电子技术的迅猛发展&#xff0c;FPGA&#xff08;可编程逻辑器件&#xff09;工程师成为了备受瞩目的职业之一。FPGA工程师不仅需要掌握硬件设计的基本原理&#xff0c;还需要具备良好的编程能力和解决问题的实践经验。面对如此竞争激烈的行…
阅读更多...
语音识别之百度语音试用和OpenAiGPT开源Whisper使用

语音识别之百度语音试用和OpenAiGPT开源Whisper使用

0.前言: 本文作者亲自使用了百度云语音识别,腾讯云,java的SpeechRecognition语言识别包 和OpenAI近期免费开源的语言识别Whisper(真香警告)介绍了常见的语言识别实现原理 1.NLP 自然语言处理(人类语言处理) 你好不同人说出来是不同的信号表示 单位k 16k16000个数字表示 1秒160…
阅读更多...
木工手工笔记

木工手工笔记

文章目录 连接两根木棍两根电线连接榫卯连接隔空划线塑料热熔密封万能的502扳手模具修复模具修复进阶 手工活真的很解压。简单整理下吧。 以前对物理知识不是很重视&#xff0c;现在发现很有用&#xff0c;很多地方都能用到。 连接两根木棍 中心划线&#xff0c;螺丝钉打入&am…
阅读更多...
C语言中关于操作符的理解

C语言中关于操作符的理解

本篇文章只会列出大家在生活中经常使用的操作符 算术操作符 在算数操作符中常用的有&#xff0c;&#xff0c;-&#xff0c;*&#xff0c;/&#xff0c;% &#xff0c;我们重点讲一讲 / (除) 和 % (模) " / "运算 #include <stdio.h>int main() {int a5/2;fl…
阅读更多...
字符串变换最小字符串（100用例）C卷

字符串变换最小字符串（100用例）C卷

从前有个村庄，村民们喜欢在各种田地上插上小旗子，旗子上标识了各种不同的数字。某天集体村民决定将覆盖相同数字的最小矩阵形的土地的分配给为村里做出巨大贡献的村民，请问，此次分配士地，做出贡献的村民中最大会分配多大面积? 输入描述: 第一行输入m和n，m代表村子的土地…
阅读更多...
最新文章

Copyright @ 2022~2023