Kafka服务端异步刷盘性能测试

前置条件：

每条话单大概0.7K

写客户端单线程

props.put("acks","all");

props.put("retries", 0);

props.put("batch.size", 16384);

props.put("linger.ms", 100);

props.put("buffer.memory", 33554432);

props.put("key.serializer","org.apache.kafka.common.serialization.IntegerSerializer");

props.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");

 

写性能测试数据:

一个分区一个备份：

1. 客户端生产1000万条话单消息,每一万条消息缓存发送一次

开始时间time=Apr 21, 2017 3:57:26 PM

结束时间time=Apr 21, 2017 3:58:26 PM

写性能为:16.6万/s

 

2. 客户端生产1亿条话单消息,每一万条消息缓存发送一次

开始时间time=Apr 21, 2017 4:01:53 PM

结束时间time=Apr 21, 2017 4:12:19 PM

写性能为:16.6万/s

 

3. 客户端生产1000万条话单消息,每100条消息缓存发送一次

开始时间time=Apr 21, 2017 4:34:02 PM

结束时间time=Apr 21, 2017 4:35:41 PM

写性能为:10万/s

 

--结论: 从1和2可见同样情况下,kafka的写速度跟数据量几乎无关，保持平稳，从1和3可见，kafka的速度和每次缓存发送的条数有关，发送数据量越小越频繁则写性能下降。

 

===============================================================================

一个分区三个备份：

4. 客户端生产1000万条话单消息,每100条消息缓存发送一次

开始时间time=Apr 21, 2017 4:48:19 PM

结束时间time=Apr 21, 2017 4:53:41 PM

写性能为:3.1万/s

 

--结论: 从3和4可见同样情况下，写入一个备份的速度高于写入三个备份的速度

 

===============================================================================

三个分区三个备份：

5. 客户端生产1000万条话单消息,每100条消息缓存发送一次

开始时间time=Apr 21, 2017 5:01:53 PM

结束时间time=Apr 21, 2017 5:04:58 PM

写性能为:5.4万/s

 

--结论: 从4和5可见同样情况下，多个分区（3个分区分布在不同节点上）能提高写的性能。

 

 

===============================================================================

上面是正常的性能测试，根据消息提醒的业务要求，很可能是每条消息发送一次，所以下面数据为每次发送1条话单的测试结果：

 

6.单线程情况下，客户端生产100万条话单消息，客户端1行话单缓存发送一次：

开始时间time=Apr 27, 2017 3:41:57 PM

结束时间time=Apr 27, 2017 3:51:04 PM

写性能为:0.18万/s

 

7.多线程情况下（10个线程共用一个KafkaProducer对象），客户端生产300万条话单消息，客户端1行话单缓存发送一次：

开始时间time=Apr 28, 2017 9:16:03 AM

结束时间time=Apr 28, 2017 9:23:21 AM

写性能为:0.68W/s

 

8. 多线程情况下（10个线程各用一个KafkaProducer对象），客户端生产100万条话单消息，客户端1行话单缓存发送一次：

开始时间time=Apr 27, 2017 5:14:02 PM

结束时间time=Apr 27, 2017 5:15:26 PM

写性能为:1.2w/s

 

--结论: 从6和7 、8 可见在同样情况下，客户端多线程的写操作能提高kafka的写性能，另外多线程使用多个KafkaProducer对象能在非常频繁的和服务端交互的情况下提高写的性能。

 

 

 

 

 

 

读性能测试:

前提条件：

props.put("auto.commit.interval.ms","1000");

props.put("key.deserializer","org.apache.kafka.common.serialization.IntegerDeserializer");

props.put("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer");

props.put("enable.auto.commit","false");

 

三个分区三个备份：

1.手工提交情况下，消费者端一次获取一条话单，并且同步提交，一共获取1000万条话单：

开始时间time=Apr 25, 2017 11:30:28 AM

结束时间time=Apr 25, 2017 1:04:23 PM

读性能: 0.17w/s

 

2.手工提交情况下，消费者端一次获取一条话单，并且异步提交，一共获取1000万条话单：

开始时间time=Apr 25, 2017 2:21:05 PM

结束时间time=Apr 25, 2017 3:32:15 PM

读性能:0.23w/s

 

--结论: 从1和2 ，可见同样情况下，异步确认是比同步确认效率要高

 

3.手工提交情况下，消费者端一次获取1000条话单，并且异步提交，一共获取900万条话单：

开始时间time=Apr 26, 2017 5:59:25 PM

结束时间time=Apr 26, 2017 6:02:31 PM

读性能:4.8w/s

 

--结论: 从2和3可见同样情况下，一次读请求获取消息数量越大，读性能越高。

 

上述前提条件改成：

props.put("enable.auto.commit", "true");--自动提交

 

4. 自动提交情况下（每秒提交一次），消费者端一次获取1000条话单，自动提交，一共获取1372万条话单：

开始时间time=Apr 26, 2017 4:51:02 PM

结束时间time=Apr 26, 2017 4:55:30 PM

读性能:5.1w/s

 

--结论:从3,4可见，每隔一秒自动提交一次跟每获取1000条消息提交一次性能相差不大。

 

 

总结：从上述测试数据来看，kafka服务端异步刷盘的情况下，kafka写性能跟每次发送的消息数量关系最大，尽量提高每次发送的缓存数据量是提高kafka写性能的重要因素，如果由于业务要求比较极端（比如一次发送一条消息）的情况下，可以提高客户端的线程数来提高写效率。Kafka的读性能跟每次读请求的消息数量大小关系最大，每次读请求读的消息量越大，读效率越高。由此可见，对于kafka的读写效率而言，性能瓶颈不在于kafka服务端，而在客户端与服务端的频繁的网络访问消耗。