Kafka与Rocketmq生产者生产吞吐量比测报告

最新推荐文章于 2024-08-25 09:39:59 发布
最新推荐文章于 2024-08-25 09:39:59 发布
阅读量1.9k 收藏 3
点赞数
文章标签： kafka 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37844106/article/details/124734777
版权

前言

本人才疏学浅，所设计测试方法及程序可能并不合理，欢迎批评指正。

Linux环境

centos7，3g运行内存，30g存储内存

Kafka测试原思路

条件：单主题、单副本、单节点
采用方法：使用自带测试脚本，消息总数不变，增加每秒发送消息数，延迟最低时接近最大吞吐量。
执行命令如下（消息总数每次执行时进行修改）：
问题：后续模拟多主题环境困难

bin/kafka-producer-perf-test.sh --num-records 10000000 --record-size 1024 --topic test --throughput 200000 --producer-props bootstrap.servers=127.0.0.1:9092 > logs/test.log

查看日志内容（每次执行后结果汇总）：

10000000 records sent, 63754.773639 records/sec (62.26 MB/sec), 11.66 ms avg latency, 608.00 ms max latency, 10 ms 50th, 19 ms 95th, 29 ms 99th, 493 ms 99.9th.
10000000 records sent, 64253.312258 records/sec (62.75 MB/sec), 12.53 ms avg latency, 635.00 ms max latency, 10 ms 50th, 20 ms 95th, 34 ms 99th, 535 ms 99.9th.
10000000 records sent, 63926.765497 records/sec (62.43 MB/sec), 15.22 ms avg latency, 870.00 ms max latency, 10 ms 50th, 20 ms 95th, 46 ms 99th, 774 ms 99.9th.
10000000 records sent, 62859.872772 records/sec (61.39 MB/sec), 12.73 ms avg latency, 792.00 ms max latency, 10 ms 50th, 19 ms 95th, 34 ms 99th, 670 ms 99.9th.
10000000 records sent, 63918.593280 records/sec (62.42 MB/sec), 12.27 ms avg latency, 697.00 ms max latency, 9 ms 50th, 19 ms 95th, 32 ms 99th, 603 ms 99.9th.
10000000 records sent, 63061.245081 records/sec (61.58 MB/sec), 13.69 ms avg latency, 916.00 ms max latency, 10 ms 50th, 19 ms 95th, 37 ms 99th, 838 ms 99.9th.

含义：
发送总消息数 单条消息大小（字节） 每秒发送条数 结果编号 最大延迟（毫秒） 平均延迟 95%（毫秒） 99% 99.9% 平均每秒写入信息（MB/sec）

结论：Kafka 在该条件下最大吞吐量位于 约 60000条消息每秒

Rocketmq测试：

条件:单主题、单副本、单节点
方法：编写java程序测试

public void test(@RequestParam long messageNum, @RequestParam int threadCount){
    //number 消息总数   threadcount 线程数
    //用于存放各线程执行消息数
    final long[] msgNums = new long[threadCount];
    //将消息平均分配给各线程
    if (messageNum > 0) {
        Arrays.fill(msgNums, messageNum / threadCount);
        long mod = messageNum % threadCount;
        if (mod > 0) {
            msgNums[0] += mod;
        }
    }

    class NameTreadFactory implements ThreadFactory {

        private final AtomicInteger mThreadNum = new AtomicInteger(1);

        @Override
        public Thread newThread(@NonNull Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    ThreadFactory threadFactory = new NameTreadFactory();

    final ExecutorService sendThreadPool = new ThreadPoolExecutor(threadCount, threadCount, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<>(),threadFactory);

    List<Message> messages = new ArrayList<>();
    for (int j = 0; j < 3000; j++) {
        Message message = new Message("batchTopic", "tag",new byte[1024]);
        messages.add(message);
    }

    for (int i = 0; i < threadCount; i++) {

        final long msgNumLimit = msgNums[i];
        if (messageNum > 0 && msgNumLimit == 0) {
            break;
        }

        int finalI = i;
        sendThreadPool.execute(() -> {

            System.out.println("线程"+ finalI +"启动");
            int num = 0;
            do {
                try {
                    producer.send(messages);
                } catch (MQClientException | RemotingException | MQBrokerException | InterruptedException e) {
                    e.printStackTrace();
                }
                num = num +20000;
            } while (num <= msgNumLimit);
        });
    }
}

发送总消息数 单条消息大小（字节） 线程数 每秒写入消息条数
10000000 1024 1 约16491
10000000 1024 3 约36380
10000000 1024 5 约50000
10000000 1024 7 约43000
10000000 1024 9 约34000

执行结果截图：
线程数：1
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
线程数：3
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
线程数: 5
在这里插入图片描述
在这里插入图片描述

线程数：7
在这里插入图片描述
在这里插入图片描述
线程数：9
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

结论：
Rocketmq在该条件下达到最大吞吐量为 50000条消息每秒

Kafka测试新思路

利用CMAK监测kafka吞吐量
for循环不断执行：

public void send(String topic,String message){
    kafkaTemplate.send(topic,message);
}

执行结果截图：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
结论：
在该条件下最大吞吐量达到约130000条每秒
设置50个分区
最大吞吐量达到约160000条每秒

多主题：
利用以下程序模拟64个主题（实际真正执行时，一次只同时操作了6个主题）

@GetMapping("sendToConsumer")
public void sendMessage() {

    class NameTreadFactory implements ThreadFactory {

        private final AtomicInteger mThreadNum = new AtomicInteger(1);

        @Override
        public Thread newThread(@NonNull Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    ThreadFactory threadFactory = new NameTreadFactory();

    final ExecutorService sendThreadPool = new ThreadPoolExecutor(6, 6, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), threadFactory);

    for (int i = 0; i < 6; i++) {
        int first = i;
        sendThreadPool.execute(() -> {

            for (int j = 0; j < 6; j++) {
                String topicName = first + "_" + j;
                for (int k = 0; k < 10000000; k++) {
                    producer.send(topicName, "JK在做测试");
                }
            }

});
}
}

程序启动初期：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
程序启动末期：
在这里插入图片描述
在这里插入图片描述
结论：
在多主题情况下kafka吞吐量呈下降趋势
该条件下最大吞吐量位于80000-90000之间 下降约30000-40000条消息每秒

Rocketmq 多主题：

@GetMapping("/produce3")
public void sendMessage() {

    class NameTreadFactory implements ThreadFactory {

        private final AtomicInteger mThreadNum = new AtomicInteger(1);

        @Override
        public Thread newThread(@NonNull Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    ThreadFactory threadFactory = new NameTreadFactory();

    final ExecutorService sendThreadPool = new ThreadPoolExecutor(6, 6, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), threadFactory);

    for (int i = 0; i < 6; i++) {
        int first = i;
        sendThreadPool.execute(() -> {

            for (int j = 0; j < 6; j++) {
                String topicName = first + "_" + j;
                for (int k = 0; k < 10000000; k++) {
                    Message message = new Message(topicName,"tag","JK在做测试".getBytes(StandardCharsets.UTF_8));
                    try {
                        producer.send(message);
                    } catch (MQClientException | RemotingException | MQBrokerException | InterruptedException e) {
                        return;
                    }
                }
                System.out.println(topicName+"执行结束");
            }
        });
    }
}

在这里插入图片描述

@GetMapping("/produce3")
public void sendMessage() {

    class NameTreadFactory implements ThreadFactory {

        private final AtomicInteger mThreadNum = new AtomicInteger(1);

        @Override
        public Thread newThread(@NonNull Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    ThreadFactory threadFactory = new NameTreadFactory();

    final ExecutorService sendThreadPool = new ThreadPoolExecutor(6, 6, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), threadFactory);

    List<Message> messages = new ArrayList<>();
    for (int j = 0; j < 5000; j++) {
        Message message = new Message("batchTopic", "tag","JK在做测试".getBytes(StandardCharsets.UTF_8));
        messages.add(message);
    }

    for (int i = 0; i < 6; i++) {
        int first = i;
        sendThreadPool.execute(() -> {

            for (int j = 0; j < 6; j++) {
                int num = 0;
                String topicName = first + "_" + j;
                do {
                    try {
                        producer.send(messages);
                    } catch (MQClientException | RemotingException | MQBrokerException | InterruptedException e) {
                        return;
                    }
                    num = num +5000;
                }while(num <10000000);
                System.out.println(topicName+"执行结束");
            }
        });
    }
}

在这里插入图片描述

@GetMapping("/produce3")
public void sendMessage() {

    class NameTreadFactory implements ThreadFactory {

        private final AtomicInteger mThreadNum = new AtomicInteger(1);

        @Override
        public Thread newThread(@NonNull Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    ThreadFactory threadFactory = new NameTreadFactory();

    final ExecutorService sendThreadPool = new ThreadPoolExecutor(6, 6, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), threadFactory);

    List<Message> messages = new ArrayList<>();
    for (int j = 0; j < 10000; j++) {
        Message message = new Message("batchTopic", "tag","JK在做测试".getBytes(StandardCharsets.UTF_8));
        messages.add(message);
    }

    for (int i = 0; i < 6; i++) {
        int first = i;
        sendThreadPool.execute(() -> {

            for (int j = 0; j < 5; j++) {
                int num = 0;
                String topicName = first + "_" + j;
                do {
                    try {
                        producer.send(messages);
                    } catch (MQClientException | RemotingException | MQBrokerException | InterruptedException e) {
                        return;
                    }
                    num = num +5000;
                }while(num <10000000);
                System.out.println(topicName+"执行结束");
            }
        });
    }
}

在这里插入图片描述
结论：若采用相同发送方式，rocketmq最大吞吐量仅约4000条消息每秒
改变测试方式，同单主题时测试方式，最大吞吐量达到约50000条消息每秒
通单主题测试时 几乎没有衰减

最终结论

Kafka在单主题条件下，使用官方自测脚本，吞吐量约为60000条消息每秒，
使用java程序测试时，单分区条件下吞吐量约为130000条消息每秒，增加分区数到50，
Kafka达到约160000条消息每秒。
在多主题情况下（模拟64个主题，实际只达到了6个主题同时写入），使用java程序测试，吞吐量约为80000-90000条消息每秒。
RocketMQ单主题情况下，使用Java程序测试，吞吐量约为50000条消息每秒，
多主题情况下（模拟64个主题，实际只达到了6个主题同时写入）使用同kafka完全一致的测试方式，吞吐量仅为4000条消息每秒，
修改方法，同单主题测试时类似，此时吞吐量仍约为50000条消息每秒。
结合自测结果及网上其他结果推论：
Kafka在单主题时吞吐量呈明显优势优于rocketmq
但随着主题数的增加，kafka的吞吐量必然要小于rocketmq。

juqen
关注
Kafka vs RocketMQ—— Topic数量对单机性能的影响1
08-03
然而，随着Topic数量的增加，Kafka的吞吐量下降明显，降幅达到98.37%，而RocketMQ的吞吐量下降较小，仅为16%。这是因为Kafka的每个Topic和分区都对应一个物理文件，Topic增多导致磁盘IO竞争加剧；而RocketMQ的消息...
Kafka 单个节点每秒 2000万 条消息，吞吐量达到每秒 600MB，Kafka 为什么这么快？如何做到这么高的性能？...
架构师小秘圈
08-31 6684
文章来源：https://juejin.cn/post/7134463012563320868有人说：他曾在一台配置较好的机子上对 Kafka 进行性能压测，压测结果是 Kafka 单个节点的极限处理能力接近每秒 2000万 条消息，吞吐量达到每秒 600MB。那 Kafka 为什么这么快？如何做到这个高的性能？本篇文章主要从这 3 个角度来分析：生产端服务端 Broker消费端先来看下生产端发送...
阿里二面：RockeMQ 是如何通过 mmap 大幅提升单机吞吐量的？
m0_73311735的博客
05-06 611
可靠的FIFO和严格有序的消息队列中间件。2011年：业界出现了现在被很多大数据领域所推崇的Kafka消息引擎，阿里巴巴在研究了Kafka的整体机制和架构设计之后，基于Kafka的设计使用Java进行了完全重写并推出了MetaQ 1.0版本，主要是用于解决顺序消息和海量堆积的问题。我们知道，在操作系统的中，数据通常都是被放在磁盘中的，只有在需要计算的时候，才会将数据加载到内存中，而每次加载的单位都是以“页”作为基础，假设我们需要访问一块存在于磁盘，但是没有被加载到内存中的数据，这种情况，我们称之为。
rocketmq 是参考了 kafka架构, 为什么rocketmq吞吐量是10万/秒, kafka吞吐量是17万/秒?
最新发布
m0_75137040的博客
08-25 398
我们都知道, 为了防止消息在服务器丢失, 一般都是进行持久化(保存在磁盘), 在发送消失时那就涉及到从磁盘拷贝到内核空间, 从内核空间到用户态, 再从用户态到socket缓存区, 从socket缓存区到网卡 四次拷贝。总结:没有完美的架构, 很难做到既要, 又要, 牺牲一部分能力换取另一部分, 从而适应不同场景需求。而rocketmq使用的是零拷贝-mmp, 把内核态数据映射到用户态, 只减少一次拷贝,kafka使用的是零拷贝-sendfile, 把内核态数据发送到网卡, 减少两次拷贝,
Kafka
qq_41850601的博客
12-20 1165
概述 Kafka是一个分布式的、可分区的、可复制的消息系统。 Kafka特点 ①高吞吐量：Kafka每秒可以生产约25万消息（50MB），每秒处理 55 万消息（110 MB） ②持久化数据存储：可进行持久化操作。将消息持久化到磁盘，因此可用于批量消费，例如 ETL，以及实时应用程序。通过将数据持久化到硬盘以及 replication 防止数据丢失。 ③分布式系统易于扩展：所有的 producer...
kafka汇总
qq_34352013的博客
11-23 1009
kafka也是一种消息队列：异步，解耦，削峰 生产消费 消息队列 分类 1、Pull to Pull - P2P - 点对点模式 市面上绝大部分的消息队列都是点对点模式或者支持点对点模式 点对点模式下，数据往往只能被消费一次 2、Publish/Subscribe - 发布订阅模式 市面上会有较少的队列使用发布订阅模式 发布者订阅模式下，数据往往可以被多次消费 作用 解耦：生产者和消费者之间不会再...
Kafka为什么⽐RocketMQ的吞吐量要⾼
qq_33240556的博客
01-13 587
Kafka的⽣产者采⽤的是异步发送消息机制，当发送⼀条消息时，消息并没有发送到Broker⽽是缓存起来，然后直接向业务返回成功，当缓存的消息达到⼀定数量时再批量发送给Broker。● 磁盘顺序读写：kafka消息不能修改以及不会从⽂件中间删除保证了磁盘顺序读，kafka的消息写⼊⽂件都是追加在⽂件末尾，不会写⼊⽂件中的某个位置(随机写)保证了磁盘顺序写。Broker在启动的时候向所有的NameServer注册，并保持⻓连接，每30s发送⼀次⼼跳。kafka⾼性能的原因。● 数据传输的零拷⻉。
rocketmq测试用例
04-09
- 消息吞吐量：测量在不同压力下，RocketMQ 的最大消息发送和接收速率。 - 延迟测试：评估消息从发送到接收的延迟，尤其是在大量并发请求下。 6. **消息分发策略**： - 分布式一致性哈希：测试消息的均衡分布，...
kafka开发和rocketmq消息技术文档
12-20
2. **高吞吐量**：Kafka 可以处理每秒数十万条消息，这得益于其基于磁盘的数据存储和高效的批量读写机制。 3. **持久性**：Kafka 将消息持久化到磁盘，确保消息即使在服务器故障后也能被恢复。 4. **分区与复制**...
RocketMq快速入门文档
02-10
RocketMQ支持十万级别的数据吞吐量，处理速度可达毫秒级，适用于构建大型分布式系统的消息传递。 ### 1. MQ简介 **1.1 项目工程弊端** 在传统的服务器架构中，A功能需要依赖B和C模块来完成任务，这导致了强耦合性...
Rocketmq原理&最佳实践
01-27
2. 选择合适的Master-Slave策略：根据业务需求，合理配置Master-Slave比例，确保数据安全性和吞吐量的平衡。 3. 定期监控和维护：监控Name Server和Broker的状态，定期清理旧数据，避免存储空间耗尽。 4. 优化消费者...
手写RocketMq详细操作手册
12-10
它在阿里巴巴双11等大型活动中发挥着关键作用，能够处理海量消息堆积、提供高吞吐量以及可靠重试等特性。RocketMQ 采用主题（Topic）的发布与订阅模式，核心功能包括消息发送、存储（Broker）和消费。 **NameServer...
rocketmq 开发规范 精讲 精华部分
12-19
RocketMQ不仅提供了异步解耦和流量削峰的能力，还支持海量消息堆积和高吞吐量，确保消息的可靠重试。在存储选型上，RocketMQ提供了顺序消息和延时消息的功能。 **顺序消息**： 局部顺序是指在特定Sharding Key的...
Apache Kafka面试题
02-19
- **总结**: Kafka 在单机吞吐量方面显著优于其他消息队列系统，尤其是比 ActiveMQ 和 RabbitMQ 高出一个数量级。 综上所述，Apache Kafka 是一款高性能、分布式的消息发布订阅系统，它不仅提供了高效的数据传输...
RocketMQ讲义-03.pdf
04-25
* **异步解耦**：MQ通过异步通信模式，使得生产者和消费者无需直接耦合，降低系统间的依赖性，提高系统的灵活性和响应速度。 * **削峰填谷**：MQ能够临时存储大量消息，避免因瞬时流量高峰导致服务崩溃，起到流量...
RocketMq知识体系
qq_34150524的博客
04-19 486
积累知识、完善体系，成为更好的自己！
RocketMQ 概念
wistchen
10-02 397
RocketMQ介绍 简介 RocketMQ是一款分布式、队列模型的消息中间件。 特点 单机吞吐量：十万级 可用性：非常高分布式架构 支持10亿级别的消息堆积，不会因为堆积导致性能下降 能够保证严格的消息顺序 提供丰富的消息拉取模式 实时的消息订阅机制 支持上万个队列 消息失败重试机制 关键概念 主题与标签 主题Top： 第一级消息类型，书的标题 标签Tags：第二级消息类型，书的目录，可以基于Tag做消息过滤 ps： 主题Top： 订单交易 标签Tags：订
Rabbitmq笔记
王举
10-08 1889
定义：RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。
消息队列MQ选型：ActiveMQ、RabbitMQ、Kafka与RocketMQ解析
Kafka是大数据领域的热门选择，擅长处理高吞吐量流式数据；而RocketMQ是阿里巴巴开源的MQ，特别适合大规模分布式系统，具备高并发、低延迟的特性。 在选择MQ时，需要根据业务需求、性能要求、社区支持等因素综合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值