【消息队列 MQ 专栏】消息队列之 Kafka

Springboot3整合消息队列Kafka Kafka 是一个分布式的流处理平台,由 LinkedIn 公司开发。它是一种高吞吐量、低延迟的消息传递系统,主要用于处理实时数据流和日志数据。Kafka 是一个基于发布-订阅(publish-subscribe)的模型,通过将消息存储在不同的 topic(主题)中,允许多个消费者并行地消费数据。 阅读详情

点击上方“芋道源码”,选择“置顶公众号”

技术文章第一时间送达!

源码精品专栏

 

Kafka 特点

Kafka 最早是由 LinkedIn 公司开发一种分布式的基于发布/订阅的消息系统,之后成为 Apache 的顶级项目。主要特点如下:

1. 同时为发布和订阅提供高吞吐量

Kafka 的设计目标是以时间复杂度为 O(1) 的方式提供消息持久化能力,即使对TB 级以上数据也能保证常数时间的访问性能。即使在非常廉价的商用机器上也能做到单机支持每秒 100K 条消息的传输。

2. 消息持久化

将消息持久化到磁盘,因此可用于批量消费,例如 ETL 以及实时应用程序。通过将数据持久化到硬盘以及 replication 防止数据丢失。

3. 分布式

支持 Server 间的消息分区及分布式消费,同时保证每个 partition 内的消息顺序传输。这样易于向外扩展,所有的producer、broker 和 consumer 都会有多个,均为分布式的。无需停机即可扩展机器。

4. 消费消息采用 pull 模式

消息被处理的状态是在 consumer 端维护,而不是由 server 端维护,broker 无状态,consumer 自己保存 offset。

5. 支持 online 和 offline 的场景。

同时支持离线数据处理和实时数据处理。

Kafka 中的基本概念

img

1. Broker

Kafka 集群中的一台或多台服务器统称为 Broker

2. Topic

每条发布到 Kafka 的消息都有一个类别,这个类别被称为 Topic 。(物理上不同Topic 的消息分开存储。逻辑上一个 Topic 的消息虽然保存于一个或多个broker上,但用户只需指定消息的 Topic 即可生产或消费数据而不必关心数据存于何处)

3. Partition

Topic 物理上的分组,一个 Topic 可以分为多个 Partition ,每个 Partition 是一个有序的队列。Partition 中的每条消息都会被分配一个有序的 id(offset)

4. Producer

消息和数据的生产者,可以理解为往 Kafka 发消息的客户端

5. Consumer

消息和数据的消费者,可以理解为从 Kafka 取消息的客户端

6. Consumer Group

每个 Consumer 属于一个特定的 Consumer Group(可为每个 Consumer 指定Group Name,若不指定 Group Name 则属于默认的 Group)。这是 Kafka 用来实现一个 Topic 消息的广播(发给所有的 Consumer )和单播(发给任意一个 Consumer )的手段。一个 Topic 可以有多个 Consumer Group。Topic 的消息会复制(不是真的复制,是概念上的)到所有的 Consumer Group,但每个 Consumer Group 只会把消息发给该 Consumer Group 中的一个 Consumer。如果要实现广播,只要每个 Consumer 有一个独立的 Consumer Group 就可以了。如果要实现单播只要所有的 Consumer 在同一个 Consumer Group 。用 Consumer Group 还可以将 Consumer 进行自由的分组而不需要多次发送消息到不同的 Topic 。

Kafka 安装

Mac 用户用 HomeBrew 来安装,安装前要先更新 brew

brew update

接着安装 kafka

brew install kafka

安装完成之后可以查看 kafka 的配置文件

cd /usr/local/etc/kafka
kafka 配置文件

kafka 需要用到 zookeeper,HomeBrew 安装kafka 的时候会同时安装 zookeeper。下面先启动 zookeeper:

zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties

接着启动 kafka

cd /usr/local/Cellar/kafka/0.11.0.1
./bin/kafka-server-start /usr/local/etc/kafka/server.properties

创建 topic,设置 partition 数量为2,topic 的名字叫 test-topic,下面的例子都用这个 topic

cd /usr/local/Cellar/kafka/0.11.0.1
./bin/kafka-topics --create --zookeeper localhost:2181 --replication-factor 1 --partitions 2 --topic test-topic

查看创建的 topic

cd /usr/local/Cellar/kafka/0.11.0.1
./bin/kafka-topics --list --zookeeper localhost:2181

Kafka 命令行测试

发送消息

cd /usr/local/Cellar/kafka/0.11.0.1/bin
kafka-console-producer --broker-list localhost:9092 --topic test-topic

消费消息

cd /usr/local/Cellar/kafka/0.11.0.1/bin
kafka-console-consumer --bootstrap-server localhost:9092 --topic test-topic --from-beginning

删除 topic

cd /usr/local/Cellar/kafka/0.11.0.1/bin
./bin/kafka-topics --delete --zookeeper localhost:2181 --topic test-topic

如果 kafka 启动时加载的配置文件中 server.properties 没有配置delete.topic.enable=true,那么此时的删除并不是真正的删除,而是把 topic 标记为:marked for deletion

查看所有 topic

cd /usr/local/Cellar/kafka/0.11.0.1/bin
./bin/kafka-topics --zookeeper localhost:2181 --list

物理删除 topic

登录zookeeper客户端:/usr/local/Cellar/zookeeper/3.4.10/bin/zkCli
找到topic所在的目录:ls /brokers/topics
找到要删除的topic,执行命令:rmr /brokers/topics/test-topic 即可,此时topic被彻底删除

Java 客户端访问

1. maven工程的pom文件中添加依赖

<dependency>
   <groupId>org.apache.kafka</groupId>
   <artifactId>kafka-clients</artifactId>
   <version>0.11.0.1</version>
</dependency>

2. 消息生产者

package org.study.kafka;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.HashMap;
import java.util.Map;
public class ProducerSample {
   public static void main(String[] args) {
       Map<String, Object> props = new HashMap<String, Object>();
       props.put("zk.connect", "127.0.0.1:2181");//zookeeper 的地址
       props.put("bootstrap.servers", "localhost:9092");//用于建立与 kafka 集群连接的 host/port 组。
       props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
       props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
       props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
       props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
       String topic = "test-topic";
       Producer<String, String> producer = new KafkaProducer<String, String>(props);
       producer.send(new ProducerRecord<String, String>(topic, "idea-key2", "java-message 1"));
       producer.send(new ProducerRecord<String, String>(topic, "idea-key2", "java-message 2"));
       producer.send(new ProducerRecord<String, String>(topic, "idea-key2", "java-message 3"));
       producer.close();
   }
}

3. 消息消费者

package org.study.kafka;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import java.util.Arrays;
import java.util.Properties;
public class ConsumerSample {
   public static void main(String[] args) {
       String topic = "test-topic";// topic name
       Properties props = new Properties();
       props.put("bootstrap.servers", "localhost:9092");//用于建立与 kafka 集群连接的 host/port 组。
       props.put("group.id", "testGroup1");// Consumer Group Name
       props.put("enable.auto.commit", "true");// Consumer 的 offset 是否自动提交
       props.put("auto.commit.interval.ms", "1000");// 自动提交 offset 到 zookeeper 的时间间隔,时间是毫秒
       props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
       props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
       Consumer<String, String> consumer = new KafkaConsumer(props);
       consumer.subscribe(Arrays.asList(topic));
       while (true) {
           ConsumerRecords<String, String> records = consumer.poll(100);
           for (ConsumerRecord<String, String> record : records)
               System.out.printf("partition = %d, offset = %d, key = %s, value = %s%n", record.partition(), record.offset(), record.key(), record.value());
       }
   }
}

4. 启动 zookeeper

zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties

5. 启动 kafka 服务器

kafka-server-start /usr/local/etc/kafka/server.properties

6. 运行 Consumer

先运行 Consumer ,这样当生产者发送消息的时候能在消费者后端看到消息记录。

7. 运行 Producer

运行 Producer,发布几条消息,在 Consumer 的控制台能看到接收的消息

Consumer 控制台

Kafka 集群配置

kafka 的集群配置一般有三种,即: single node - single broker ,single node - multiple broker ,multiple node - multiple broker

前两种实际上官网有介绍。

single node - single broker

单节点单 broker
1. 启动 zookeeper
zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties
2. 启动 kafka broker
kafka-server-start /usr/local/etc/kafka/server.properties
3. 创建一个 kafka topic
kafka-topics --create --zookeeper localhost:2181 --replication-factor 1 --partitions 2 --topic topic-singlenode-singlebroker
4. 启动 producer 发送信息
kafka-console-producer --broker-list localhost:9092 --topic topic-singlenode-singlebroker

broker-list 和 topic 这两个参数是必须的,broker-list 指定要连接的 broker 的地址,格式为 node_address:port 。topic 是必须的,因为需要发送消息给订阅了该topic 的 consumer group 。现在可以在命令行里输入一些信息,每一行会被作为一个消息。

发送消息
5. 启动 consumer 消费消息
kafka-console-consumer --bootstrap-server localhost:9092 --topic topic-singlenode-singlebroker

在不同的终端窗口里分别启动 zookeeper、broker、producer、consumer 后,在producer 终端里输入消息,消息就会在 consumer 终端中显示了。

消息显示

single node - multiple broker

单节点多 broker
1. 启动 zookeeper
zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties
2. 启动broker

如果需要在单个节点(即一台机子)上面启动多个 broker(这里作为例子启动三个 broker),需要准备多个server.properties文件即可,所以需要复制 /usr/local/etc/kafka/server.properties 文件。因为需要为每个 broker 指定单独的属性配置文件,其中 broker.id 、 port 、 log.dir 这三个属性必须是不同的。

新建一个 kafka-example 目录和三个存放日志的目录

mkdir kafka-example
mkdir kafka-logs-1
mkdir kafka-logs-2
mkdir kafka-logs-3

复制 /usr/local/etc/kafka/server.properties 文件三份

cp server.properties /Users/niwei/Downloads/kafka-example/server-1.properties
cp server.properties /Users/niwei/Downloads/kafka-example/server-2.properties
cp server.properties /Users/niwei/Downloads/kafka-example/server-3.properties

在 broker1 的配置文件 server-1.properties 中,相关要修改的参数为:

broker.id=1
port=9093
log.dirs=/Users/niwei/Downloads/kafka-example/kafka-logs-1

broker2 的配置文件 server-2.properties 中,相关要修改的参数为:

broker.id=2
port=9094
log.dirs=/Users/niwei/Downloads/kafka-example/kafka-logs-2

broker3 的配置文件 server-3.properties 中,相关要修改的参数为:

broker.id=3
port=9095
log.dirs=/Users/niwei/Downloads/kafka-example/kafka-logs-3

启动每个 broker

cd /Users/niwei/Downloads/kafka-example
kafka-server-start server-1.properties
kafka-server-start server-2.properties
kafka-server-start server-3.properties
3. 创建 topic

创建一个名为 topic-singlenode-multiplebroker 的topic

kafka-topics --create --zookeeper localhost:2181 --replication-factor 3 --partitions 1 --topic topic-singlenode-multiplebroker
4. 启动 producer 发送信息

如果一个 producer 需要连接多个 broker 则需要传递参数 broker-list

kafka-console-producer --broker-list localhost:9093, localhost:9094, localhost:9095 --topic topic-singlenode-multiplebroker
5. 启动 consumer 消费消息
kafka-console-consumer --zookeeper localhost:2181 --topic topic-singlenode-multiplebroker
单节点多 broker 消费消息

multiple node - multiple broker

多节点多 broker

搭建 zookeeper 集群

1. Kafka 的集群配置
broker.id=1  #当前机器在集群中的唯一标识
port=9093 #当前 kafka 对外提供服务的端口,默认是 9092
host.name=192.168.121.101 #这个参数默认是关闭的,在0.8.1有个bug,DNS解析问题,失败率的问题。
log.dirs=/Users/niwei/Downloads/kafka-example/kafka-logs-1 #消息存放的目录,这个目录可以配置为逗号分割的表达式
zookeeper.connect=192.168.120.101:2181,192.168.120.102:2181,192.168.120.103:2181 #设置 zookeeper 集群的连接端口
num.network.threads=3 #这个是 borker 进行网络处理的线程数
num.io.threads=5 #这个是 borker 进行 IO 处理的线程数
socket.send.buffer.bytes=102400 #发送缓冲区的大小,数据先回存储到缓冲区了到达一定的大小后在发送能提高性能
socket.receive.buffer.bytes=102400 #接收缓冲区的大小,当数据到达一定大小后在序列化到磁盘
socket.request.max.bytes=104857600 #这个参数是向 kafka 请求消息或者向 kafka 发送消息的请求的最大数,这个值不能超过 jvm 的堆栈大小
num.partitions=1 #默认的分区数,一个 topic 默认1个分区数
log.retention.hours=24 #默认消息的最大持久化时间,24小时
message.max.byte=5242880  #消息保存的最大值5M
default.replication.factor=2  #kafka 保存消息的副本数,如果一个副本失效了,另一个还可以继续提供服务
replica.fetch.max.bytes=5242880  #取消息的最大直接数
log.segment.bytes=1073741824 #这个参数是因为 kafka 的消息是以追加的形式落地到文件,当超过这个值的时候,kafka 会新建一个文件
log.retention.check.interval.ms=300000 #每隔 300000 毫秒去检查上面配置的 log 失效时间(log.retention.hours=24 ),到目录查看是否有过期的消息如果有则删除
log.cleaner.enable=false #是否启用 log 压缩,一般不用启用,启用的话可以提高性能

由于是多节点多 broker 的,所以每个 broker 的配置文件 server.properties 都要按以上说明修改

2. producer 的配置修改
kafka-console-producer --broker-list 192.168.21.1:9092,192.168.21.2:9092,192.168.21.3:9092 --topic topic-multiplenode-multiplebroker
3. consumer 的配置修改
kafka-console-consumer --zookeeper 192.168.120.101:2181,192.168.120.102:2181,192.168.120.103:2181 --topic topic-multiplenode-multiplebroker

Kafka 高可靠性配置

Kafka 提供了很高的数据冗余弹性,对于需要数据高可靠性的场景可以增加数据冗余备份数(replication.factor),调高最小写入副本数的个数(min.insync.replicas)等等,但是这样会影响性能。反之,性能提高而可靠性则降低,用户需要自身业务特性在彼此之间做一些权衡性选择。

要保证数据写入到 Kafka 是安全的、高可靠的,需要如下的配置:

1. topic 的配置

replication.factor>=3,即副本数至少是3个2<=min.insync.replicas<=replication.factor

2. broker 的配置

leader 的选举条件 unclean.leader.election.enable=false

3. producer 的配置

request.required.acks=-1,producer.type=sync

Kafka 高吞吐量的秘诀

消息中间件从功能上看就是写入数据、读取数据两大类,优化也可以从这两方面来看。

为了优化写入速度 Kafak 采用以下技术:

1. 顺序写入

磁盘大多数都还是机械结构(SSD不在讨论的范围内),如果将消息以随机写的方式存入磁盘,就需要按柱面、磁头、扇区的方式寻址,缓慢的机械运动(相对内存)会消耗大量时间,导致磁盘的写入速度与内存写入速度差好几个数量级。为了规避随机写带来的时间消耗,Kafka 采取了顺序写的方式存储数据,如下图所示:

顺序写
消费消息

2. 内存映射文件

即便是顺序写入硬盘,硬盘的访问速度还是不可能追上内存。所以 Kafka 的数据并不是实时的写入硬盘,它充分利用了现代操作系统分页存储来利用内存提高I/O效率。Memory Mapped Files (后面简称mmap)也被翻译成内存映射文件,在64位操作系统中一般可以表示 20G 的数据文件,它的工作原理是直接利用操作系统的 Page 来实现文件到物理内存的直接映射。完成映射之后对物理内存的操作会被同步到硬盘上(由操作系统在适当的时候)。通过 mmap 进程像读写硬盘一样读写内存,也不必关心内存的大小,有虚拟内存为我们兜底。使用这种方式可以获取很大的 I/O 提升,因为它省去了用户空间到内核空间复制的开销(调用文件的 read 函数会把数据先放到内核空间的内存中,然后再复制到用户空间的内存中)但这样也有一个很明显的缺陷——不可靠,写到 mmap 中的数据并没有被真正的写到硬盘,操作系统会在程序主动调用 flush 的时候才把数据真正的写到硬盘。所以 Kafka 提供了一个参数—— producer.type 来控制是不是主动 flush,如果Kafka 写入到 mmap 之后就立即 flush 然后再返回 Producer 叫同步(sync);如果写入 mmap 之后立即返回,Producer 不调用 flush ,就叫异步(async)。

3. 标准化二进制消息格式

为了避免无效率的字节复制,尤其是在负载比较高的情况下影响是显著的。为了避免这种情况,Kafka 采用由 Producer,Broker 和 Consumer 共享的标准化二进制消息格式,这样数据块就可以在它们之间自由传输,无需转换,降低了字节复制的成本开销。

而在读取速度的优化上 Kafak 采取的主要是零拷贝

零拷贝(Zero Copy)的技术:

传统模式下我们从硬盘读取一个文件是这样的

文件传输到 Socket 的常规方式

(2) 应用将数据从内核空间读到用户空间的缓存中

(3) 应用将数据写会内核空间的套接字缓存中

(4)操作系统将数据从套接字缓存写到网卡缓存中,以便将数据经网络发出

这样做明显是低效的,这里有四次拷贝,两次系统调用。针对这种情况 Unix 操作系统提供了一个优化的路径,用于将数据从页缓存区传输到 socket。在 Linux 中,是通过 sendfile 系统调用来完成的。Java提供了访问这个系统调用的方法:FileChannel.transferTo API。这种方式只需要一次拷贝:操作系统将数据直接从页缓存发送到网络上,在这个优化的路径中,只有最后一步将数据拷贝到网卡缓存中是需要的。

零拷贝方式传输到 Socket

Kafka 速度的秘诀在于它把所有的消息都变成一个的文件。通过 mmap 提高 I/O的速度,写入数据的时候是末尾添加所以速度最优;读取数据的时候配合sendfile 直接暴力输出。所以单纯的去测试 MQ 的速度没有任何意义,Kafka 的这种暴力的做法已经脱了 MQ 的底裤,更像是一个暴力的数据传送器。



知识星球

目前在知识星球(https://t.zsxq.com/2VbiaEu)更新了如下 Dubbo 源码解析如下:

01. 调试环境搭建
02. 项目结构一览
03. API 配置(一)之应用
04. API 配置(二)之服务提供者
05. API 配置(三)之服务消费者
06. 属性配置
07. XML 配置
08. 核心流程一览

09. 拓展机制 SPI

10. 线程池

...
一共 60 篇++

大数据技术Kafka详解 ① | 消息队列(Messages Queue) 大数据技术Kafka详解 ① | 消息队列 阅读详情

相关推荐

FitzHugh-Nagumo 模型连续-MATLAB仿真

【代码】FitzHugh-Nagumo 模型连续-MATLAB仿真。

qq_43688618的博客 887

消息队列之 Kafka

Kafka 特点 Kafka 最早是由 LinkedIn 公司开发一种分布式的基于发布/订阅的消息系统,之后成为 Apache 的顶级项目。主要特点如下: 1. 同时为发布和订阅提供高吞吐量 Kafka 的设计目标是以时间复杂度为 O(1) 的方式提供消息持久化能力,即使对TB 级以上数据也能保证常数时间的访问性能。即使在非常廉价的商用机器上也能做到单机支持每秒 100K 条消息的传输。 2. 消...

weixin_33845477的博客 289

手把手教你在全新服务器内网安装OpenEuler 22.03 LTS SP4+ 安装 openGuass 5.0.0(LTS) 数据库

openEuler是面向数字基础设施的操作系统,支持服务器、云计算、边缘计算、嵌入式等应用场景,支持多样性计算,致力于提供安全、稳定、易用的开源服务器Linux操作系统。

cgqyw的专栏 3741

消息队列基本知识

消息队列(Message Queue)简称MQ消息队列是采用"异步(两个微服务项目并不需要同时完成请求)"的方式来传递数据完成业务操作流程的业务处理方式如果我们真的将上面生成订单业务里,减少库存的操作从正常流程中剥离到消息队列那么如果库存减少过程中发生异常,就不能由Seata接收了,因为异步的处理无法和Seata通信意思是如果使用了消息队列,队列中处理数据过程发送异常,那么就要用特殊的方法处理问题处理方式就是手写代码进行回滚,一般情况就是在stock,模块再向order模块发送消息,order模块接收到消息

Melody_1943的博客 3209

深入浅出:用状态机搞定FPGA MIG控制器与DDR3的读写时序(附Verilog源码分析)

本文深入解析了如何利用状态机精准控制FPGA MIG控制器与DDR3的读写时序,涵盖Verilog源码实现、关键时序控制点及实战优化技巧。通过状态机设计、跨时钟域处理和带宽优化等方法,有效提升DDR3访问效率,适用于高性能计算和AI加速器等场景。

weixin_26899659的博客 412

Rokid眼镜高精度图像识别的五大工程破局点

图像识别是AR交互的基础能力,其核心在于将现实图像映射为可计算的数字特征,并通过几何建模解算空间姿态。在专用AR眼镜场景中,该过程面临光学畸变、传感器时序错位、低延迟跟踪与人因适配等复合挑战。尤其在工业现场,Rokid Max系列的鱼眼镜头畸变、IMU-视觉异步采样、窄FOV下快速眼动等物理约束,使传统基于AR Foundation或OpenCV的识别方案失效。本文聚焦真实部署中的关键瓶颈,涵盖实时反畸变纹理渲染、原生SDK直调优化、端侧轻量CNN模型(TinyImageNet-Rokid)、IMU-视觉紧

weixin_33681778的博客 700

消息队列

消息队列(message queue)是分布式应用之间交换信息的一种技术。通过消息队列,应用程序可以独立执行,他们不需要知道彼此的未知。 1.使用场景 异步通信:消息队列提供了异步处理机制,允许用户把一个消息放到队列里,但并不实时处理,等到需要的时候再处理。 解耦:降低工程之前的强依赖,通过消息系统在处理过程中间插入了一个隐含的、基于数据的接口层,两边的处理过程都要实现这一接口,当应用发生变化时,可以独立的扩展或修改两边的处理过程,只要确保它们遵守同样的接口约束。 削峰:当有大量流量请求一个系统时,

林竹清_清清清 809

EB tresos配置指南:CAN通信信号收发全流程解析

本文详细解析了使用EB tresos配置工具实现AUTOSAR架构下CAN通信信号收发功能的全流程。从环境准备、COM模块信号定义、PduR路由配置、CanIf硬件抽象到CAN驱动层设置,提供了清晰的步骤指南和关键配置要点,帮助开发者快速打通从应用层到物理层的数据链路,实现可靠的CAN通信。

weixin_29192141的博客 513

消息队列看这一篇就够了!

我们介绍了消息队列的生产者消费者模型,以及异步解耦这2个经典引用场景,最后浅析了一个demo的具体实现。

BenJamin_Blue的博客 3458

把 ABAP 接到外部世界的几条路, 从 Web Service 到 RFC、BAPI 与 IDoc 的完整理解

摘要: ABAP 的连接能力是其长期成为企业核心的关键,不仅支持通用协议(HTTP、SOAP、XML),还保留了 SAP 特有的技术(RFC、BAPI、IDoc)。Web Service 是跨系统通信的主轴,依赖 SOAP/WSDL 实现契约化协作,而 Enterprise Service 更强调业务语义的复用与治理。经典技术如 RFC 和 BAPI 因高效稳定仍广泛使用,尤其适合紧耦合场景。ABAP 通过分层工具箱(如代理生成、服务注册)实现灵活集成,平衡新旧技术,满足多样化的企业连接需求。 (字数:15

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 142

Docker/Hyper-V/Wsl2等虚拟化组件一键切换工具 (附源码, Docker Desktop开发模式与三角洲游戏模式一键切换工具)

开启 Docker、Hyper-V 或 WSL2 后游戏无法启动?🎮💻 本文教你用一键批处理工具⚡快速切换“开发/游戏模式”,开发娱乐两不误!🔄✨

XiaoqiangClub的博客 703

消息队列基础知识

消息队列如何保证消息可靠传输 可靠意味着:生产者不重复生产消息(多)、消费者不重复消费消息(多)、消息在传输中不能丢失(少) 1、消息重复: 对于生产者,一般不会出现多生产的情况。不过为了配合消费者的重复判断逻辑实现,可以在生成消息时,多加一个全局唯一id,这样消费者在每次拿到消息后根据id判断是否消费过 对于消费者,不能重复消费,我们可以通过实现幂等性来实现,或者说即使重复消费了,也不会对结果产生影响(我们也需要从代码的层面去实现,比如数据库的唯一索引) 2、消息丢失 生产者发送消息时,一定要确认

weixin_44453179的博客 370

【YOLOs-CPP-图像分类部署】04-项目优化(加速部署)

本文详细介绍了将YOLO图像分类C++部署项目从CMake迁移到Visual Studio控制台应用的全过程。针对低配CPU性能瓶颈问题,作者通过替换多线程HPP代码为官方实现,并采用448x448固定输入尺寸优化推理速度。项目配置包含OpenCV和ONNX Runtime环境设置,实现了图像批量处理、分类结果显示及结果日志输出功能。关键步骤包括依赖库配置、DLL部署和代码调试,最终在Windows平台成功实现高效CPU推理。该方案显著提升了低配硬件的兼容性,为图像分类任务提供了稳定的部署解决方案。

深耕CV 355

KisFlow-Golang流式实时计算案例(四)-KisFlow在消息队列MQ中的应用

Golang框架实战-KisFlow流式计算框架(1)-概述 Golang框架实战-KisFlow流式计算框架(2)-项目构建/基础模块-(上) Golang框架实战-KisFlow流式计算框架(3)-项目构建/基础模块-(下) Golang框架实战-KisFlow流式计算框架(4)-数据流 Golang框架实战-KisFlow流式计算框架(5)-Function调度 Golang框架实战-KisFlow流式计算框架(6)-Connector Golang框架实战-KisFlow流式计算框架(7)-配置导入

rita_0567的博客 824

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

【消息中间件】详解三大MQ:RabbitMQ、RocketMQ、Kafka

一文详解三大MQ,RabbitMQ、RocketMQ、Kafka,各自的使用、原理和适用场景。

BugMan的博客 2万+

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

【MQ】消息队列概述

消息队列:一般我们简称为MQ(Message Queue)Message Queue :消息队列中间件,很多初学者认为,MQ通过消息的发送和接受来实现程序的异步和解耦。mq主要用于异步操作,这个并不是mq的真正目的,这只是mq的应用,mq的真正目的是为了通讯。

m0_62645012的博客 1790

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

《深入剖析Kafka分布式消息队列架构奥秘》之Kafka基本知识介绍

    Kafka是一个分布式系统,由服务器和客户端组成,这些服务器和客户端通过高性能TCP网络协议进行通信,它可以部署在本地和云中的裸机硬件、虚拟机和容器环境。

shsjssnn的博客 1444

【Kafka基础篇】RabbitMQ、RocketMQ、Kafka怎么选?3种主流MQ核心差异实测解析

本文深入探讨了消息队列的核心价值与主流MQ对比,重点解析Kafka从消息队列到分布式流处理平台的演进历程。文章首先回顾消息队列的解耦、削峰和异步通信三大核心价值,以及点对点与发布订阅两大通信模型。随后对比RabbitMQ、RocketMQ和Kafka的架构特性,指出Kafka的高吞吐量源于日志式存储和批量处理机制。最后详细阐述Kafka通过引入流处理API和生态集成,实现了从基础消息传递到完整流处理闭环的升级,成为大数据领域的核心组件。全文为开发者提供了MQ选型指导和技术演进洞察。

m0_58782205的博客 1745

【Kafka从入门到放弃系列 零】Kafka看这一篇就够了

系统间的耦合高怎么办,我们如何不让一个服务过于庞大,一个好的方式就是依据具体的功能模块拆分服务,降低服务的耦合度,服务间的交互可以通过消息传递数据来实现,除此之外Kafka非常适合在线日志收集等高吞吐场景,kafka有更好的吞吐量,内置分区,副本和故障转移,这有利于处理大规模的消息,所以kafka被各大公司广泛运用于消息队列的构建: 消息队列模型-生产者消费者模型 Kafka基本概念和架构模型 Kafka工作流程和文件存储机制 生产者策略:分区策略、数据可靠性保证、故障转移机制 消费者策略:消费方式、分区

MaoLin Tian's Blog 6827

【Redis实战】有MQ为啥不用?用Redis作消息队列!?Redis作消息队列使用方法及底层原理高级进阶

Redis作为消息队列的优缺点: 使用Redis作为消息队列的选择相对于使用专门的消息队列系统(如RabbitMQ、Kafka等)有以下优点和: 简单轻量:Redis是一个内存中的数据存储系统,具有轻量级和简单的特点。相比较专门的消息队列系统,使用Redis作为消息队列不需要引入额外的组件和依赖,可以减少系统的复杂性。 速度快:由于Redis存储在内存中,它具有非常高的读写性能。这对于需要低延迟的应用程序非常有优势。 多种数据结构支持:Redis提供了丰富的数据结构,如列表、发布/订阅、有序集合等。这使

终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路 4103

消息队列MQ/JMS/Kafka,你都了解吗?

点击上方☝码猿技术专栏轻松关注,设为星标!及时获取有趣有料的技术是不是平常听到说消息队列啊,JMS啊,MQ啊 、kafka啊巴啦啦的一堆术语,听不懂?关系混乱?今天就让我们来一起来看看他...

码猿技术专栏 387

【MQ篇】初识MQ!

想象一下,你开了一家网店,顾客下单后,你需要通知仓库发货、更新库存、给用户发送短信等等。如果没有MQ,你的系统可能就要像这样:顾客下单 -> 调用仓库系统 -> 等待仓库响应 -> 调用库存系统 -> 等待库存响应 -> 调用短信服务 -> 等待短信服务响应 -> 订单完成这就像让快递员直接跑遍所有环节,效率低下不说,万一哪个环节出了问题(比如仓库系统崩了),整个下单流程就卡住了!😱而MQ就像一个“快递中转站”。

qq_56158663的博客 1424

置顶必读(1) |《SpringBoot + MQ全家桶实战》专栏导读,简直夯爆了!

🏆 本文收录于 《SpringBoot + MQ全家桶实战》 专栏。 专栏围绕 Spring Boot 环境下主流消息中间件的 集成、原理、实战、选型与架构设计 展开,覆盖 RabbitMQ、Kafka、RocketMQ、Pulsar、NATS、ZeroMQ 等常见消息技术栈,持续更新中,欢迎订阅学习。

**My Coding Family** 3万+
上一篇: Java中高级面试题(5)
下一篇: 【RPC 专栏】深入理解 RPC 之动态代理篇
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值