京东开源热key探测(JD-hotkey)中间件单机qps 2万提升至35万实录

原创
08/28 15:24
阅读数 2.5W

京东hotkey框架(JD-hotkey)是京东app后台研发的一款高性能热数据探测中间件,用来实时探测出系统的热数据,并将热数据毫秒内推送至系统的业务集群服务器的JVM内存。以下统称为"热key"。

该框架主要用于对任意突发性的无法预先感知的热key,包括并不限于热点数据(如突发大量请求同一个商品)、热用户(如恶意爬虫刷子)、热接口(突发海量请求同一个接口)等,进行毫秒级精准探测到。然后对这些热key,推送到所有服务端JVM内存中,以大幅减轻对后端数据存储层的冲击,并可以由使用者决定如何分配、使用这些热key(譬如对热商品做本地缓存、对热用户进行拒绝访问、对热接口进行熔断或返回默认值)。这些热数据在整个服务端集群内保持一致性,并且业务隔离,worker端性能强悍。

之前在发布过该框架架构设计的文章( https://my.oschina.net/1Gk2fdm43/blog/4331985 ),详细讲述了框架的工作原理,如果看完本文不太能理解背景、工作原理的建议先看上一篇架构设计做初步理解。目前该框架已在京东App后台、数据中台、白条、金融、商家等多十余个业务部门接入运行,目前应用最广泛的场景是刷子(爬虫)用户实时探测和redis热key实时探测。

由于框架自身核心点在于实时(准实时,可配置1-500ms内)探测系统运行中产生的热key,而且还要面临随时可能突发的暴增流量(如突发抢购某商品),还要在探测出热key后在毫秒时间内推送到该业务组的几百、数千到上万台服务器JVM内存中,所以对于它的单机性能要求非常高。

根据之前的文章,我们知道框架的计算单元worker端,它的工作流程是:启动一个netty server,和业务服务器(数百——上万)建立长连接,业务服务器批量定时(1——500ms一次)上传自己的待测key给worker,worker对发来的key进行滑动窗口累加计算,达到用户设置的阈值(如某个类型的key,pin_xxxx达到2秒20次),则将该key推送至整个业务服务器集群内,从而业务服务器可以在内存中使用这些热key,到达设置的过期时间后会自动过期删除。

截止目前,该框架0.4版本的性能表现如下(硬件配置为随机机房创建的16核docker容器):

1 key探测计算:每秒可接收N台服务器发来的40多万个待测key,并计算完毕其中的35万左右。实测可每秒稳定计算30万,极限计算37万,超过的量会进入队列等待。

2 热key推送:当热key产生后,对该业务集群所有长连接的服务器进行key推送,每秒可稳定推送10-12万次(毫秒内送达)。譬如1千台服务器,每秒该worker可以支撑产生100个热key,即推送100*1000次。当每秒产生200个热key,即每秒需要推送20万次时,会出现有1s左右的延迟送达。强度压测当每秒要推送50万次时,出现了极其明显的延迟,推送至client端的时间已不可控。在所有积压的key推送完毕后,可继续正常工作。

注意,推送是和接收30万key并行的,也就是进和出加起来吞吐量在40多万每秒。

以上为单机性能表现,通过横向扩展,可以提升对应的处理量,不存在单点问题,横向扩展中无性能瓶颈。以当前的性能表现,单机可以完成1000台业务服务器的热key探测任务。系统设计之初,期望值是单机能支撑200台业务器的日常计算,所以目前性能是高于预期的,在逐步的优化过程中,也遇到了很多问题,本文就是对这个过程中所遇到的与性能有关的问题和优化过程,做个记录。

以下所有数据,不特殊指明的话,均默认是随机机房的16核docker容器,属于共享型资源,实际配置强于8核物理机,弱于16核物理机。

初始版本——2万QPS

该版本采用的是jdk1.8.20(jdk的小版本影响很大),worker端采用的架构方式为netty默认参数+disruptor重复消费模式。

netty默认开启cpu核数*2个线程,作为netty的工作线程,用于接收几千台机器发来的key,接收到待测key后,全部写入到disruptor的生产者线程,生产者是单线程。之后disruptor同样是cpu核数*2个消费者线程,每个消费者都重复消费每条发来的key。

这里很明显的问题,大家都能看到,disruptor为什么要重复消费每个key?

因为当初的设想是将同一个key固定交给同一个线程进行累加计算,以避免多线程同时累加同一个key造成数量计算错误。所以每个消费者线程都全部消费所有的key,譬如8个线程,线程1只处理key的hash值为1的,其他的return不处理。

该版本上线后,长连接3千台业务服务器,单机每秒处理几千个key的情况下,cpu占用率在20%多。猛一看,貌似还可以接受的样子是吗。

其实不是的,该版本随后经历了618大促压测演练,首次压测,该版本在压测开始的一瞬间就已经生活不能自理了。

首次压测量级只有10万,我有4台worker,平均每台也就2万多秒级key写入,而cpu占用率直接飙升至100%,系统卡的连10s一次的定时任务都不走了,完全僵死状态。

那么问题在哪里?仅通过猜测我们大概考虑是disruptor负载比较重,譬如是不是因为重复消费的问题?

要寻找问题在哪里,进入容器内部,查看top的进程id,再使用top -H -p1234(1234为javaa进行pid),再使用jstack命令导出java各个线程的状态。

在top -H这一步,我们看到有巨多的线程在占用cpu,数量之多,令见者伤心、闻者落泪。

里面有大量的如下

也就是说大量的disruptor消费者线程吃光了cpu,说好的百万并发框架disruptor性能呢?

当然,这次的锅不能给disruptor去背。这次的问题首要罪魁祸首是jdk版本问题,我们使用的1.8.0_20在docker容器内通过Runtime.getRuntime().availableProcessors()方法获取到的数量是宿主机的核数,而不是分配的核数。

即便只分配这个容器4核8核,该方法取到的却是宿主机的32核、64核,直接导致netty默认分配的高达128个线程,disruptor也是128个线程。这几百个线程一开启,平时空闲着就占用20%多的cpu,压测一开始,cpu直接原地起飞,忙于轮转,瞬间瘫痪。

首次优化——10万QPS

jdk在1.8.0_191之后,修复了容器内获取cpu核数的问题,我们首先升级了jdk小版本,然后增加了对不同版本cpu核数的判断逻辑,把线程数降了下来。

这其中我并没有去修改disruptor所有线程都消费key的逻辑,保持了原样。也就是说,16核机器,目前是32个netty IO线程,32个消费者业务线程。再次上线,cpu日常占用率降低到7%-10%左右。

二次压测开始,从下图每10秒打印一次的日志来看,单机秒级计算完毕的key在8万多,同时秒级推送量在10万左右。

此时cpu已经开始飘高了,当单机秒级达到14万时,CPU接近跑满状态,此时已达线上平稳值上限10万。其中占用cpu较多的依旧是disruptor大量的线程。

二次优化——16万QPS

考虑到线程数对性能影响还是很大,该应用作为纯内存计算框架,是典型的cpu密集型,根本不需要那么多的线程来做计算。

我大幅调低了netty的IO线程数和disruptor线程数,并随后进行了多次实验。首先netty的IO线程分别为4和8反复测试,业务线程也调为4和8进行反复测试。

最终得出结论,netty的IO线程在低于4时,秒级能接收到的key数量上限较低,4和8时区别不太大。而业务线程在高于8时,cpu占用偏高。尤其是key发来的量比较少时,线程越多,cpu越高。注意,是发来的key更少,cpu更高,当完全没有key发来时,cpu会比有key时更高。

原因在于disruptor它的策略就是会反复轮询队列是否有可消费的数据,没有数据时,它这个轮询空耗cpu,即便等待策略是BlockingWaitStrategy。

所以,最终定下了IO线程和业务线程分别为8,即核数的一半。一半用来接收数据,一半用来做计算。

从图上可以看到,秒级可以处理完毕16万个key,cpu占用率在40%。

加大压力源后,实际处理量会继续提升,但此时我对disruptor的实际表现并不满意,总是在每百万key左右就出现几个发来的key在被消费时就已经超时(key发送时比key被处理时超过5秒)的情况。追查原因也无果,就是个别key好像是被遗忘在角落一样,迟迟未被处理。

三次优化——25万QPS

由于对disruptor不满意,所以这一次直接丢弃了它,改为jdk自带的LinkedBlockQueue,这是一个读写分别加锁的队列,比ArrayBlockQueue性能稍好,理论上不如disruptor性能好。

原因大家应该都清楚,首先ArrayBlockQueue读写同用一把锁,LinkedBlockQueue是读一把锁、写一把锁,ArrayBlockQueue肯定是性能不如LinkedBlockQueue。

disruptor采用ringbuffer环形队列,如果生产消费速率相当情况下,理论上读写均无锁,是生产消费模型里理论上性能最优的。然而,一切都要靠场景和最终成绩来说话,网上抛开了这些单独谈框架性能其实没有什么意义。

同样是8线程读取key然后写入到队列,8线程死循环消费队列。此时已经不会重复消费了,我采用了别的方式来避免多线程同时计算同一个key的数量累加问题。

再次上线后,首先非常明显的变化就是再也没有key被处理时发生超时的情况了,之前每百万必出几个,而这个Queue几亿也没一个超时的,每个写入都会迅速被消费。另一个非常直观的感受就是cpu占用率明显下降。

在平时的日常生产环境,disruptor版在秒级几千key,3千个长连接情况下,cpu占用在7%-10%之间,不低于5%。而BlockQueue版上线后,日常同等状态下,cpu占用率0.5%-1%之间,即便是后来我加入了秒级监控这个单线程挺耗资源的逻辑(该逻辑会统计累加所有client每秒的key访问数据,单线程cpu占用单核50%以上),cpu占用率也才在1.5%,不超过2%。

此时压测可以看到,秒级处理量能达到25-30万,cpu占用率在70%。cpu整体处于比较稳定的状态,该压测持续N个小时,未见任何异常。

并且该版也进行过并发写入同时对推送的压测,稳定推送每秒10-12万次可保持极其稳定毫秒级送达的状态。在20万次时开始出现延迟送达,极限每秒压至48万次推送,出现大量延迟,部分送达至业务client时延迟已超过5秒,此时我们认为热key毫秒级推送功能在如此延迟下已不能达到既定目的。读写并行情况下,吞吐量在40万左右。

这一版也是618大促期间线上运行的版本(秒级监控是618后加入的功能)。

最近优化——35万QPS

之前所有版本,都是通过fastjson进行的序列化和反序列化,两端通信时交互的对象都是fastjson序列化的字符串,采用netty的StringDecoder进行交互。

这种序列化和反序列化方式在平时使用中,性能处于足够的状态,几千几万个小对象序列化耗时很少。大家都知道一些其他的序列化方式,如protobuf、msgPack等。

本地测试很容易,搞个只有几个属性的对象,做30万次序列化、反序列化,对比json和protobuf的耗时区别。30万次,大概相差个300-500ms的样子,在量小时几乎没什么区别,但在30万QPS时,差的就是这几百ms。

网上相关评测序列化方式的文章也很多,可以自行找一些看看对比。

在更换序列化方式,修改netty编解码器后,压测如图:

秒级16万时,cpu大概25%。

秒级36.5万时,cpu在50%的样子。

此时,每秒压力机发来的key在42万以上,但处理量维持在36万左右,不能继续提升。因为多线程消费LinkedBlockQueue,已达到该组件性能上限。netty的IO线程尚未达到接收上限。

争议项

其实从上面的生产消费图大家都能看出来,所有netty收到的消息都发到了BlockQueue里,这是唯一的队列,生产消费者都是多线程,那么必然是存在锁竞争的。

很多人都会考虑为何不采用8个队列,每个线程只往一个队列发,消费者也只消费这一个线程。或者干脆去掉队列,直接消费netty收到的消息。这样不就没有锁竞争了吗,性能不就能再次起飞?

这个事情自然我也是多次测试过了,首先通过上面的压测,我们知道瓶颈是在BlockQueue那里,它一秒被8线程消费了37万次,已经不能再高了,那么8个队列只要能超过这个数值,就代表这样的优化是有效的。

然而实际测试结果并不让人满意,分发到8个队列后,实际秒级处理量骤降至25万浮动。至于直接在netty的IO线程做业务逻辑,这更不可取,如果不小心可能导致较为严重的积压,甚至导致客户端阻塞。

虽然网上很多文章都专门讲锁竞争导致性能下降,避免锁来提升性能,但在这种30万以上的场景下,实践的重要性远大于理论。至于为什么会性能变差,就留给大家思考一下吧。

后记

可能大家觉得哇塞你这个调优好简单,我也学会了,就是减少线程数,那么实际是这样吗?

我们再来看看,线程少时导致吞吐量大幅下降的场景。

之前我们的测试都是说每秒收到了多少万个key,处理了多少万个key,大部分负载都是处理key上。现在我们来测试一下纯推送量,只接收很少的key,然后让所有的key都是热key,开启很多个客户端,每秒推送很多次。

测试是这样的,由一个单独的client每秒发送1万个key到单个worker,设置变热规则为1,那么这1万个就全是热key,然后我分别采用40、60、80、100个client端机器,这样就意味着每秒单个worker要推送40、60、80、100万次,通过观察client端每秒是否接收到了1万个热key推送来判断worker的推送极限。

首先还是使用上面的配置,即8个IO线程,8个消费者线程。

可以看到8线程在每秒推送40万次时比较稳定,在client端打日志也是基本1秒1万个全部收到,没有超时的情况。在60万次时,cpu大幅抖动,大部分能及时推送到达,但开始出现部分超时送达的情况。上到60万以上时,系统已不可用,大量的超时,所有信息都超时,开始出现推送积压,堆外内存持续增长,逐渐内存溢出。

调大IO线程至16,推送量每秒60万:

持续运行较长时间,cpu非常稳定,未出现8线程时那种偶尔大幅抖动的情况,稳定性比之前的8线程明显好很多。

随后我加大到80个客户端,即每秒推送80万次。

总体还是比较平稳,cpu来了60%附近,full gc开始变得频繁起来,几乎每20秒一次,但并未出现大量的超时情况,只有full gc那一刻,会有个别key在到达client时超过1秒。系统开始出现不稳定的情况。

我加大到100个client,即每秒要推送100万次。

此时系统已经明显不堪重负,full gc非常密集,cpu开始大幅抖动,大量的1秒超时,整体已经不可控了,持续运行后,就会开始出异常,内存溢出等问题。

通过对纯推送的压测,发现更多的IO线程,几乎可以到达每秒70万推送稳定,比8线程的时候40多万稳定,强了不是一点点。同样一台机器,仅改了改线程数量而已。

那么问题又来了,我们应该怎么去配置这个线程数量呢?

那么就有实际场景了,你是到底每秒有很多key要探测、但是热的不多,还是探测量一般般、但是阈值调的低、热key产生多、需要每秒推送很多次。归根到底,是要把计算资源让给IO线程多一些,还是消费者线程多一些的问题。

总结

在开发过程中,遇到了诸多问题,远不止上面调个线程数那么简单,对很多数据结构、包传输、并发、和客户端的连接处理很多地方都出过问题,也对很多地方选型做过权衡,线上以求稳为主,稳中有性能提升是最好的。

主要的结论就是一切靠实践,任何理论、包括书上写的、博客写的,很多是靠想象,平时本地运行多久都不出问题,拿到线上,百万流量一冲击,各种奇奇怪怪的问题。有些在被冲击后,过一会能恢复服务,而有些技术就不行了,就直接瘫痪只能重启,甚至于连个异常信息都没有,就那么安安静静的停止响应了。

线上真实流量+极端暴力压测是我们在每一个微小改动后都会去做的事情,力求服务极端流量不宕机、不误判。

目前该框架已在开源中国发布开源,https://gitee.com/jd-platform-opensource/hotkey,有相关热key痛点需求的可以了解一下,有定制化需求,或不满足自己场景的也可以反馈,我们也在积极采纳内外部意见建议,共建优质框架。

展开阅读全文
打赏
17
70 收藏
分享
加载中
1. disruptor的目标是写入的低延迟,从来都不是吞吐量,而且本身并不支持并发消费的场景,其次,消费积压到达上限会触发丢弃策略(默认是阻塞),丢弃策略不当也会引起性能降低。BlockingQueue的设计再吞吐量而非延迟,正好和Disruptor相反,可以利用多线程消费来增加性能,只要控制好锁,性能是可以比Disruptor高的。
2. disruptor 用hash来避免重复消费,不如用cas,hash还要计算,浪费cpu,而且hash分布不均匀也会影响处理速度。直接用value = AtomicReference#getAndSet(null); if(value == null) return;性能更优
08/31 17:49
回复
举报
靠谱。 disruptor最终还是因为他的高cpu占用被抛弃了,方方面面的原因
08/31 18:39
回复
举报
您好,请问这个框架主要用在哪里的?类似echart和redies缓存框架吗?
08/31 14:51
回复
举报
你好,不类似。用的地方在这里介绍 https://my.oschina.net/1Gk2fdm43/blog/4331985
08/31 14:53
回复
举报
我其实是关注东京热的, 结果进来看是京东热, 请给我一个东的时间
08/31 11:08
回复
举报
能不能给我一个东的时间
08/31 12:40
回复
举报
我们的关注点是一致的
08/31 18:31
回复
举报
我也是来关注东京热的
08/31 21:11
回复
举报
强啊,老哥。观摩观摩
08/31 10:53
回复
举报
所以结论就是: 1.限制线程数到合适的值; 2.disruptor还不如LinkedBlockingQueue; 3.弃用json改用protobuf
08/31 10:31
回复
举报
disruptor自测效果并没有它所描述的那么好。
08/31 11:18
回复
举报
乍一看以为是东京hot
08/31 10:16
回复
举报
我也是
08/31 11:01
回复
举报
1. 调整jdk版本,修复docker环境获取到宿主机的核心数问题。
2. 更换并发框架disruptor为jdk自带的LinkedBlockQueue。
3. 更换json序列化方式。
4. 根据具体需求场景,具体数据量大小,调整I/O线程数和消费者线程数,达到平衡。
08/31 10:11
回复
举报
666
08/31 09:37
回复
举报
探寻支持某次改动依据的获得才是提升的点
08/31 09:26
回复
举报
可以尝试下将netty替换成smart-socket,性能还会有提升的
08/31 09:25
回复
举报
框架性能瓶颈不在IO那,测试的IO量每秒在80万,瓶颈在BlockQueue这个java api的性能这,它只能吞吐30多万
08/31 09:55
回复
举报
更多评论
打赏
27 评论
70 收藏
17
分享
在线直播报名
返回顶部
顶部