微信开源 PhxQueue:“三高“的分布式队列

SAP中常见的Debug方式 原文链接:https://mp.weixin.qq.com/s/wT4kThFKYV0PQYhCqpXRWg 大家可以关注我个人公众号,所有分享内容,会在公众号第一时间推送,且阅读排版更好。 愿大家的学习,轻松且愉快。 如果大家觉得有用,希望转发关注,谢谢 导读 SAP系统在企业的应用时,都不会只使用标准功能。 通常情况下,基于特殊的行业需求,以及某些业务部门的管理需求等,都会额外开发出一些增强,报表,对话功能,接口等,从而保证系统的正常运转。 标准知识的逻辑,我们... 阅读详情

导语 本文首先介绍了微信开源分布式队列 PhxQueue 的诞生背景及架构设计,然后着重在设计、性能、存储层 Fail over 过程三方面与 Kafka 进行了对比。期望了解 PhxQueue 或 Kafka 的读者均能从中获益。
开源地址:https://git.code.oa.com/wxg-td/phxqueue

PhxQueue 是微信开源的一款基于 Paxos 协议实现的高可用、高吞吐和高可靠的分布式队列,保证At-Least-Once Delivery,在微信内部广泛支持微信支付、公众平台等多个重要业务。

消息队列概述

消息队列作为成熟的异步通信模式,对比常用的同步通信模式,有如下优势:

  1. 解耦:防止引入过多的 API 给系统的稳定性带来风险;调用方使用不当会给被调用方系统造成压力,被调用方处理不当会降低调用方系统的响应能力。
  2. 削峰和流控:消息生产者不会堵塞,突发消息缓存在队列中,消费者按照实际能力读取消息。
  3. 复用:一次发布多方订阅。

PhxQueue诞生背景

旧队列

微信初期使用的分布式队列(称为旧队列)是微信后台自研的重要组件,广泛应用在各种业务场景中,为业务提供解耦、缓存、异步化等能力。

旧队列以 Quorum NRW 作为同步机制,其中 N=3、W=R=2,刷盘方式采用异步刷盘,兼顾了性能和可用性。

新需求

随着业务发展,接入业务种类日益增多,旧队列逐渐显得力不从心,主要不足如下:

  • 异步刷盘,数据可靠性堪忧

    对于支付相关业务,保证数据可靠是首要需求。
    目前大多数分布式队列方案是以同步复制+异步刷盘来保证数据可靠性的,但我们认为需要同步刷盘来进一步提高数据可靠性。

  • 乱序问题
    部分业务提出了绝对有序的需求,但 NRW 并不保证顺序性,无法满足需求。

另外旧队列还存在出队去重、负载均衡等其他方面的问题亟需改善。上述种种促使了我们考虑新的方案。

业界方案的不足

Kafka 是大数据领域常用的消息队列,最初由 LinkedIn 采用 Scala 语言开发,用作 LinkedIn 的活动流追踪和运营系统数据处理管道的基础。

其高吞吐、自动容灾、出入队有序等特性,吸引了众多公司使用,在数据采集、传输场景中发挥着重要作用,详见Powerd By Kafka。

但我们充分调研了 Kafka,认为其在注重数据可靠性的场景下,有如下不足:

Kafka 性能与同步刷盘的矛盾

Kafka 在开启配置 log.flush.interval.messages=1,打开同步刷盘特性后,吞吐会急剧下降。

该现象由如下因素导致:

  • SSD 写放大
    业务消息平均大小在数 1k 左右。
    而 SSD 一次刷盘的最小单位为一个 page size,大小为 4k。
    当 Kafka 对大小不足 4k 的消息进行刷盘时,实际写入的物理数据量是消息大小的数倍。导致硬盘写带宽资源被浪费。
  • 业务场景下 Producer batch 效果不好
    Kafka Producer batch,简单来说,就是把多个消息打包在一起发送到 Broker,广泛用于大数据场景。按道理,batch效果足够,是能抵消写放大的影响的。
    但业务场景下的消息生产不同于大数据场景下的日志生产,每个需要入队的业务请求在业务系统中有独立的上下文,batch难度大。即使在业务和Broker之间加入代理层,将Producer转移到代理层内进行batch,也因代理层的节点数众多,batch效果难以提高,导致写放大无法抵消。

Kafka replica 同步设计上的不足

Kafka replica 同步设计概要:

Kafka Broker leader 会跟踪与其保持同步的 follower 列表,该列表称为ISR(即in-sync Replica)。如果一个 follower 宕机,或者落后太多,leader 将把它从ISR中移除。

该同步方式偏重于同步效率,但是在可用性方面表现略显不足:

  • Broker fail over 过程成功率下降严重
    在3 replicas的场景下,leader 均匀分布在各 Broker 上,一个Broker出现故障,就意味着1/3的 leader、follower 离线,这时读写成功率下降:
    • 对于 leader 离线的 partition,暂时无法读写,需要等待 Controller 选举出新的 leader 后才能恢复;
    • 对于 follower 离线的 partition,也暂时无法读写,需要等待一定时长(取决于 replica.lag.time.max.ms,默认10s)后,leader 将故障 follower 从 ISR 中剔除才能恢复。

也就是说,任意一个 Broker 故障时,读写成功率会在一段时间内降为0。

  • 同步延迟取决于最慢节点
    在同步复制场景下,需要等待所有节点返回ack。

通过对比 Kafka replica 与 Paxos 的表现,我们认为在同步方式上 Paxos 是更好的选择:

对比项Kafka replicaPaxosPaxos好处
Broker fail over 过程成功率Leader或follower的离线均会造成短暂时间内无法读写只有 leader 的离线会造成短暂时间内无法读写单节点故障后的 fail over 过程中仍有过半成功率,对大多数不要求绝对有序的业务,换节点重试可避免失败
同步延迟需要等待所有节点返回 ack,延迟取决于最慢节点只需等待多数派节点返回 ack,最慢节点并不影响整体吞吐前端等待耗时更短

所以,我们基于 Paxos 重新设计了一套分布式队列,并且进行了包括同步刷盘之内的多项优化,完成了 PhxQueue。

PhxQueue 介绍

PhxQueue 目前在微信内部广泛支持微信支付、公众平台等多个重要业务,日均入队达千亿,分钟入队峰值达一亿。

其设计出发点是高数据可靠性,且不失高可用和高吞吐,同时支持多种常见队列特性。

PhxQueue支持的特性如下:

  • 同步刷盘,入队数据绝对不丢,自带内部实时对账
  • 出入队严格有序
  • 多订阅
  • 出队限速
  • 出队重放
  • 所有模块均可平行扩展
  • 存储层批量刷盘、同步,保证高吞吐
  • 存储层支持同城多中心部署
  • 存储层自动容灾/接入均衡
  • 消费者自动容灾/负载均衡

PhxQueue 设计

整体架构

在这里插入图片描述
PhxQueue 由下列5个模块组成。

Store - 队列存储

Store 作为队列存储,引入了 PhxPaxos 库,以 Paxos 协议作副本同步。只要多数派节点正常工作及互联,即可提供线性一致性读写服务。

为了提高数据可靠性,同步刷盘作为默认开启特性,且性能不亚于异步刷盘。

在可用性方面,Store 内有多个独立的 paxos group,每个 paxos group 仅 master 提供读写服务,平时 master 动态均匀分布在 Store 内各节点,均衡接入压力,节点出灾时自动切换 master 到其它可用节点。

Producer - 生产者

Producer 作为消息生产者,根据 key 决定消息存储路由。相同 key 的消息默认路由到同一个队列中,保证出队顺序与入队顺序一致。

Consumer - 消费者

Consumer 作为消费者,以批量拉取的方式从 Store 拉消息,支持多协程方式批量处理消息。

Consumer 以服务框架的形式提供服务,使用者以实现回调的方式,根据不同主题(Topic),不同处理类型(Handler)定义具体的消息处理逻辑。

Scheduler - 消费者管理器(可选择部署)

Scheduler 的作用是,收集 Consumer 全局负载信息, 对 Consumer 做容灾和负载均衡。当使用者没有这方面的需求时,可以省略部署 Scheduler,此时各 Consumer 根据配置权重决定与队列的处理关系。

部署 Scheduler 后,Scheduler leader 与所有 Conusmer 维持心跳,在收集 Consumer 的负载信息的同时,反向调整 Consumer 与队列的处理关系。

当 Scheduler leader 宕机了后,Scheduler 依赖下述分布式锁服务选举出新 leader,不可用期间仅影响 Consumer 的容灾和负载均衡,不影响 Consumer 的正常消费。

Lock - 分布式锁(可选择部署)

Lock 是一个分布式锁,其接口设计非常通用化,使用者可以选择将 Lock 独立部署,提供通用分布式锁服务。

Lock 在 PhxQueue 中的作用有如下两点:

  • 为 Scheduler 选举 leader;
  • 防止多个 Consumer 同时处理一条队列。

Lock 同样也是可选择部署的模块:

  • 若部署了 Scheduler,就必须部署 Lock 为 Scheduler 选举出 leader;
  • 否则,若业务对重复消费不敏感,可选择不部署 Lock。

这里所指的重复消费场景是:若省略部署 Scheduler 的话,Consumer 需要通过读取配置得知可处理的队列集合;当队列有变更(如队列缩扩容)时,各 Consumer 机器上的配置改变有先有后,这时各 Consumer 在同一时间看到的配置状态可能不一样,导致一段时间内两个 Consumer 都认为自己该消费同一个队列,造成重复消费。Lock 的部署可以避免该场景下的重复消费。(注意,即使省略部署 Lock,该场景仅造成重复消费,而不会造成乱序消费)

Store 复制流程

在这里插入图片描述
PhxQueue Store 通过 PhxPaxos库 进行副本复制。

PhxPaxos 的工程实现方式分为三层:app 层负责处理业务请求,paxos 层执行 paxos同步过程,状态机层更新业务状态。

其中,app 层发起 paxos 提议,paxos 层各节点通过 paxos 协议共同完成一个 paxos log 的确认,之后状态机以 paxos log 作为的输入作状态转移,更新业务的状态,最后返回状态转移结果给 app 层。

一致的状态机层,加上来自 paxos 层的一致输入,就产生一致的状态转移,从而保证多个节点强一致。

这里我们要基于 PhxPaxos 在状态机层实现一个队列,就需要作如下概念映射:

队列概念PhxPaxos概念PhxPaxos概念解析
队列数据paxos logpaxos 日志,其值由 paxos 算法确定,在各节点内强一致
队列偏移instance idpaxos 日志的唯一编号,严格递增
队列读偏移check point构成状态机镜像的最大 instance id,该 id 之前的 paxos 日志可删除
  • 队列这种模型不涉及数据修改,是有序的数据集合,和 paxos log 的定义很像,所以可以让入队的数据直接作为 paxos log,而状态机只需要保存 paxos log 序列。
  • instance id 的严格递增特性,使得它可以方便地作为队列偏移。
  • 队列中读偏移之前的数据,认为是可以删除的数据,这点和 check point 的定义一致。

整体上队列状态机和 paxos 能很好地切合。

Store Group Commit - 高效刷盘及副本同步

未经优化的 Paxos 协议并未解决同步刷盘的写放大问题。而且,其副本同步效率不如 Kafka。

原因是,Kafka 的副本同步是流式批量的,而 Paxos 协议是以 paxos log 为单位串行同步,每个 paxos log 的同步开销是 1个RTT + 1次刷盘。

在多DC部署的场景下,ping 时延可达4ms,这样会导致单个 paxos group 的理论最高 TPS 仅250。

我们采用多 paxos group 部署 以及 Group Commit 的方式来同时解决同步刷盘的写放大问题以及Paxos吞吐问题。

在这里插入图片描述
如上图, 我们部署多个 paxos group,以 paxos group 作为 Group Commit 的单位,一个 paxos group 内对应多个 queue,将多个 queue 在一段时间内入队的数据合并在一起,当等待耗时或积累数据数目达到阀值,才会触发一次 Paxos 同步和同步刷盘,等待期间前端阻塞。

与 Kafka 的 Producer 批量逻辑相比,在存储层以 Group Commit 进行批量合并的好处如下:

  1. 业务层无需关注如何组织请求进行批量;
  2. 在存储层以 paxos group 为单位的聚合效果比上层聚合效果更好。

PhxQueue 与 Kafka 对比

下面分别从设计、性能、存储层 failover 过程三方面对比 PhxQueue 与 Kafka。

设计对比

PhxQueue 架构虽然与 Kafka 等常见分布式队列类似,但设计上仍有不少独特之处。为了能让对 Kafka 有一定了解的读者更方便地了解 PhxQueue,下面列出了两者的对比。

注:以下对比基于相同的数据可靠性场景:少数派节点失效,不会造成数据丢失,且整体依旧可用。

特性PhxQueue 设计Kafka 设计总结
水平扩展最小粒度queuepartition两者均以分区作为水平扩展的最小粒度,PhxQueue 定义为 queue,Kafka 定义为 partition。
物理文件存储粒度paxos grouppartition存储所用的物理文件数,决定了磁盘写并发。一个 paxos group/partition 对应着一个物理文件。与 Kafka 不同的是,PhxQueue 有意区分 queue 和 paxos group 的概念。一个 queue 只属于一个 paxos group,一个 paxos group 内可包含多个 queue,从而避免逻辑水平扩展影响写盘并发。
存储层的可写角色masterleaderPhxQueue 与 Kafka 均只有 master/leader 可写。
存储层 master(leader) 分布自动均匀分布到各节点自动均匀分布到各节点PhxQueue 与 Kafka 均支持 master(leader) 自动均衡,分摊接入压力到各节点。
存储层 master(leader) 选举Store 自身依赖 Paxos 选举 masterBroker 依赖 Zookeeper 选举出 Controller,再由 Controller 选举出各分区的 leaderKafka Broker 引入 Controller 解决了 Zookeeper 压力大的问题;PhxQueue Store 不依赖外部选举,每一组均能独立进行 Paxos 决议,分散了选举压力。
批量生产能力Producer、Store 均有独立的 batch 逻辑仅 Producer 有 batch 逻辑batch 逻辑是提高吞吐的杀手锏。PhxQueue 为了应对高扇入场景下 Producer 端 batch 效果不好的情况,在 Store 中加入了 batch 逻辑。
生产确认Paxos 协议,多数派 accept 即完成同步全同步协议,所有 ISR 返回 ack 后完成同步PhxQueue 只需多数派应答即可完成同步,Kafka 同步需要等待最慢节点。
存储层的组间容灾隔离有无对于 PhxQueue,Paxos 只要求组内多数节点存活即可完成写入,所以单节点离线造成的失败,可以在组内换节点重试成功;对于 Kafka,单节点离线会造成整组暂时不可写,重试逻辑需要换组进行,相当于一个组的请求转移到了别的组,有可能压垮别的组,牺牲了组间容灾隔离。
存储层的服务发现通过本地配置文件获取存储层信息通过 Metadata RPC 获取存储层信息PhxQueue 通过配置文件做服务发现,使用者需维护各机器配置的一致性;Kafka 以 Zookeeper 作为配置管理中心,为了避免性能下降及提高稳定性,没有直接将 Zookeeper 暴露给使用方,而是使用 RPC 的方式返回信息。
消费隔离以订阅(Sub)为单位以消费分组(Consumer Group)为单位两者均支持消费隔离。
消费管理各 Consumer 与 Schduler 维持心跳并上报负载,Schduler 根据负载调整各 Consumer 的消费权重,Consumer 再根据消费权重决定要处理的队列由 Coordinator 对每个 Consumer Group 选举出一个 Consumer 作为 leader,决定该 Consumer Group 内的队列分配为了适应混合部署的场景,PhxQueue 新增了负载均衡功能,当某 Consumer 负载过高时,可自动调整分配;Kafka并无该功能。

性能对比

测试环境

CPU: 64 x Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz
Memory: 64 GB
Network: 10 Gigabit Ethernet
Disk: SSD Raid 10
Cluster Nodes: 3
Ping: 1ms

测试基准及配置

基准描述基准要求PhxQueueKafka备注
刷盘并发100并发100 queues, 100 paxos group100 partitions测试环境硬盘为 SSD,高并发能获得高吞吐
副本同步方式3 replicas3 Storesreplication.factor=3;min.insync.replicas=2;request.required.acks=-13 replicas 部署;要求一个 replica 不可用时,整体仍可用,且数据不丢
入队数据大小10字节10字节无

测试结果

开启 Producer Batch:

入队 QPS(w/s)平均耗时(ms)
PhxQueue(同步刷盘)1890
Kafka(异步刷盘)18120
Kafka(同步刷盘)9290

以上场景,PhxQueue 瓶颈在 cpu,使用率达70% ~ 80%。

小结

  1. PhxQueue 性能与 Kafka 持平;
  2. 相同 QPS 下,由于不用等最慢节点返回,PhxQueue 平均耗时比 Kafka 稍优;
  3. 关闭 Producer Batch 后,在同步刷盘场景下,PhxQueue 性能可达 Kafka 的2倍,原因是,PhxQueue 存储层在写盘前做了 batch,而 Kafka 没有,所以后者会有写放大。

存储层 failover 过程对比

主要对比杀死存储层的一个节点后,对整体吞吐的影响。

Kafka

表现:

  • Failover 期间,在不同阶段程度不同,入队成功率在0% ~ 33%;
  • Failover 持续时间由租约决定,租约时长默认10s。

测试过程:

将 replica.lag.time.max.ms 从 10s 调整为 60s(延长时间方便观察),然后 kill Broker 0,挑选3个 partition,观察 ISR 变化如下:

第一阶段(未 kill Broker 0):
        Topic: test-dis-p100    Partition: 96   Leader: 0       Replicas: 0,1,2 Isr: 1,0,2
        Topic: test-dis-p100    Partition: 97   Leader: 1       Replicas: 1,2,0 Isr: 1,0,2
        Topic: test-dis-p100    Partition: 98   Leader: 2       Replicas: 2,0,1 Isr: 1,0,2
第二阶段(kill Broker 0 后持续8s):
        Topic: test-dis-p100    Partition: 96   Leader: 0       Replicas: 0,1,2 Isr: 1,0,2
        Topic: test-dis-p100    Partition: 97   Leader: 1       Replicas: 1,2,0 Isr: 1,0,2
        Topic: test-dis-p100    Partition: 98   Leader: 2       Replicas: 2,0,1 Isr: 1,0,2
第三阶段(持续1分钟左右):

 - List item

        Topic: test-dis-p100    Partition: 96   Leader: 1       Replicas: 0,1,2 Isr: 2,1
        Topic: test-dis-p100    Partition: 97   Leader: 1       Replicas: 1,2,0 Isr: 2,1,0
        Topic: test-dis-p100    Partition: 98   Leader: 2       Replicas: 2,0,1 Isr: 2,1,0
第四阶段(至此入队成功率完全恢复):
        Topic: test-dis-p100    Partition: 96   Leader: 1       Replicas: 0,1,2 Isr: 2,1
        Topic: test-dis-p100    Partition: 97   Leader: 1       Replicas: 1,2,0 Isr: 2,1
        Topic: test-dis-p100    Partition: 98   Leader: 2       Replicas: 2,0,1 Isr: 2,1

其中,第二/三阶段入队成功率受损:

  • 第二阶段期间,Partition 96/97/98 均无法写入,入队成功率成功率下降至0%。
  • 第三阶段期间,Partition 96 可继续写入,但 Partition 97/98 无法写入,因为写入要等 Broker 0 回 ack,但 Broker 0 已 kill,入队成功率下降至33%。

而实际观察,第二/三阶段期间完全没吞吐,原因是压测工具不断报连接失败,停止了写入。

压测工具输出:

30551 records sent, 6107.8 records/sec (0.06 MB/sec), 1733.9 ms avg latency, 5042.0 max latency.
30620 records sent, 6117.9 records/sec (0.06 MB/sec), 1771.9 ms avg latency, 5076.0 max latency.
30723 records sent, 6123.8 records/sec (0.06 MB/sec), 1745.4 ms avg latency, 5009.0 max latency.
30716 records sent, 6127.3 records/sec (0.06 MB/sec), 1841.1 ms avg latency, 5299.0 max latency.
30674 records sent, 6133.6 records/sec (0.06 MB/sec), 1621.3 ms avg latency, 4644.0 max latency.
>>>>>>>>>> kill Broker 0 here (入队成功率受损)>>>>>>>>>>
10580 records sent, 123.4 records/sec (0.00 MB/sec), 1537.1 ms avg latency, 84236.0 max latency.  <<-----吞吐下降严重
11362 records sent, 132.3 records/sec (0.00 MB/sec), 1658.3 ms avg latency, 84232.0 max latency.
11367 records sent, 132.3 records/sec (0.00 MB/sec), 1582.4 ms avg latency, 84228.0 max latency.
11236 records sent, 130.9 records/sec (0.00 MB/sec), 1694.2 ms avg latency, 84240.0 max latency.
11406 records sent, 132.8 records/sec (0.00 MB/sec), 1650.5 ms avg latency, 84233.0 max latency.

压测工具连接Broker失败日志:

[2017-08-16 15:38:22,844] WARN Connection to node 0 could not be established. Broker may not be available. (org.apache.kafka.clients.NetworkClient)
[2017-08-16 15:38:22,859] WARN Connection to node 0 could not be established. Broker may not be available. (org.apache.kafka.clients.NetworkClient)
[2017-08-16 15:38:22,865] WARN Connection to node 0 could not be established. Broker may not be available. (org.apache.kafka.clients.NetworkClient)
[2017-08-16 15:38:22,868] WARN Connection to node 0 could not be established. Broker may not be available. (org.apache.kafka.clients.NetworkClient)

原因分析:
Kafka Broker leader 是通过 Controller 选举出来的,ISR 列表是 leader 维护的。

前者的的租约是 Controller 定义的,后者的租约是 Broker 配置 replica.lag.time.max.ms 指定的。

所以,第二阶段持续时间较短,是 Controller 的租约时间决定的,第三阶段持续时间较长,是 replica.lag.time.max.ms 决定的。

当 Broker 0 被 kill 时,前者影响本来 Broker 0 是 leader 的 1/3 partitions 的入队成功率,后者影响 Broker 0 作为 follower 的 2/3 partitions 的入队成功率。

PhxQueue

表现:

  • Failover 期间,入队成功率仅下降至66%;
  • Failover 持续时间由租约决定,租约时长默认5s。
  • 开启 换队列重试特性(适合没有绝对顺序性要求的业务提高可用性)后,Failover 期间仍有90+%入队成功率。

测试过程:

将 Store master 租约时长从10s调整为60s(延长时间方便观察),然后kill store 0,观察某 Producer 入队成功率:

关闭换队列重试特性:

>>>>>>>>>> kill store 0 here (入队成功率受损)>>>>>>>>>>

-------------------------------------------
--      total:  192323
--      time(ms):       10015
--      qps:    19203.49
--      routine_sleep:  73.88%
--      retcode cnt     percent
--      -1      22097   11.49 <<---------------------- 失败:连接失败
--      0       125905  65.47 <<---------------------- 成功:仍有66%成功率
--      10102   44321   23.05 <<---------------------- 失败:提示需要重定向到 master
--      usetime(ms)     cnt     percent
--      < 1             0       0.00
--      < 2             0       0.00
--      < 5             610     0.32
--      < 10            7344    3.82
--      < 20            18937   9.85
--      < 50            36067   18.75
--      < 100           6971    3.62
--      < 200           20239   10.52
--      < 500           59059   30.71
--      < 1000          30601   15.91
--      >= 1000         12495   6.50

>>>>>>>>>> (入队成功率完全恢复)>>>>>>>>>>

-------------------------------------------
--      total:  198955
--      time(ms):       10001
--      qps:    19893.51
--      routine_sleep:  98.00%
--      retcode cnt     percent
--      0       198955  100.00 <<---------------------- 成功:100%成功率
--      usetime(ms)     cnt     percent
--      < 1             0       0.00
--      < 2             2       0.00
--      < 5             5895    2.96
--      < 10            30830   15.50
--      < 20            65887   33.12
--      < 50            95403   47.95
--      < 100           753     0.38
--      < 200           185     0.09
--      < 500           0       0.00
--      < 1000          0       0.00
--      >= 1000         0       0.00

开启换队列重试特性:

>>>>>>>>>> kill store 0 here (入队成功率受损)>>>>>>>>>>

-------------------------------------------
--      total:  134752
--      time(ms):       10001
--      qps:    13473.85
--      routine_sleep:  77.43%
--      retcode cnt     percent
--      -202    14      0.01 <<---------------------- 失败:超时
--      -1      2712    2.01 <<---------------------- 失败:连接失败
--      0       127427  94.56 <<------------------------- 成功:仍有94%成功率
--      10102   4572    3.39 <<---------------------- 失败:提示需要重定向到 master
--      10105   27      0.02 <<---------------------- 失败:master 未选举出来
--      usetime(ms)     cnt     percent
--      < 1             0       0.00
--      < 2             4       0.00
--      < 5             3284    2.44
--      < 10            10704   7.94
--      < 20            22109   16.41
--      < 50            32752   24.31
--      < 100           4541    3.37
--      < 200           4331    3.21
--      < 500           11265   8.36
--      < 1000          19706   14.62
--      >= 1000         26056   19.34

>>>>>>>>>> (入队成功率完全恢复)>>>>>>>>>>

-------------------------------------------
--      total:  198234
--      time(ms):       10014
--      qps:    19795.69
--      routine_sleep:  94.36%
--      retcode cnt     percent
--      0       198234  100.00 <<---------------------- 成功:100%成功率
--      usetime(ms)     cnt     percent
--      < 1             0       0.00
--      < 2             0       0.00
--      < 5             3875    1.95
--      < 10            22978   11.59
--      < 20            53000   26.74
--      < 50            87575   44.18
--      < 100           6204    3.13
--      < 200           6468    3.26
--      < 500           11963   6.03
--      < 1000          5637    2.84
--      >= 1000         534     0.27
小结
  1. 在存储层 failover 过程中,PhxQueue 和 Kafka 的入队成功率均有一定时长的下降,PhxQueue 的入队成功率在66% ~ 100%,Kafka 的入队成功率在0% ~ 33%;
  2. PhxQueue 开启换队列重试特性后,failover 过程中入队成功率保持在90+%。
  3. PhxQueue 和 Kafka 均能自动切换 master,最终入队成功率完全恢复。

总结

PhxQueue 在存储层做了很多的努力:实现了 master 自动切换,且仍然保证线性一致,切换期间仍然高可用;保证了同步刷盘的吞吐,其性能不亚于异步刷盘。

另外实现了大部分队列实用特性,例如出入队顺序一致、多订阅、限速、消息重放等,适用于各种业务场景。

目前 PhxQueue 已在微信内部大规模使用,也正式开源。

我们将保持 PhxQueue 开源版本与内部版本的一致,欢迎读者试用并反馈意见。

开源地址:https://github.com/Tencent/phxqueue

MIT液态神经网络(LNN)深度研究:原理、应用与未来 液态神经网络(Liquid Neural Networks, LNNs)代表了人工智能领域,特别是神经网络架构设计中的一次范式转移。它从根本上挑战了传统深度学习模型依赖大规模参数和静态架构的惯例,转而寻求一种更为动态、高效且受生物神经系统启发的计算范式。LNN的核心创新在于其将神经网络的计算过程从离散的、基于时间步的更新,转变为连续的、由微分方程驱动的动态系统演化。这种转变不仅赋予了模型前所未有的适应性和鲁棒性,还使其在处理复杂的时序数据和因果推断任务时表现出色。本章节将深入剖析LNN的技术原理,从其核心的 阅读详情

相关推荐

MTK pwm beeper配置记录

如果正常,系统启动后会在/dev/input下生成 一个event节点,使用方法参考标准linux使用。dts相关修改如下,全都在里面,注意一下位置。对应的配置文件中增加如下定义。

hclydao的专栏 729

微信开源PhxQueue:高可用、高可靠、高性能的分布式队列

作者| 梁俊杰编辑| 小智PhxQueue 是微信开源的一款基于 Paxos 协议实现的高可用、高吞吐和高可靠的分布式队列,保证 At-Least-Once Delivery,在微信内部广泛支持微信支付、公众平台等多个重要业务。开源地址 https://github.com/Tencent/phxqueue消息队列概述 消息队列作为成熟的异步通信模式,对比常用的同步通信模式,有如下优势:解耦:防止...

weixin_34124939的博客 427

KUKA机器人 - 从开机到自动运行

注1:本文仅代表本人对机器人使用的一些建议,在使用机器人前,还请详细阅读库卡机器人官方资料,道路千万条,安全第一条!!! 注2:技术有限,欢迎各位大大在阅读过程中发现各类问题,并且批评指正!!! 目录 一、准备工作 1. 机器人上电完成 2. 电脑安装Workvisual 二、学习手动移动机器人 三、项目配置 1. 设置机器人IP地址 2.电脑和机器人通过网线连接 3.查找并打开项目 4. 通讯配置 5. 项目上传 6. 检验IO配置 四、编程 1.新建程序 2. 程序...

yilunyao的博客 1万+

开源项目推荐:多进程和多线程的高性能消息队列(无锁队列),lock-free queue

一、多线程 1、A fast multi-producer, multi-consumer lock-free concurrent queue for C++11 https://github.com/cameron314/concurrentqueue 2、A fast single-producer, single-consumer lock-free queue for C++ h...

$firecat利白的代码足迹$ 4273

PADS Layout中快速导入自定义元器件封装的实用技巧

本文详细介绍了在PADS Layout中高效导入自定义元器件封装的实用技巧。针对封装“找不到”、“对不上”、“导不进”三大痛点,系统梳理了从封装文件来源识别、库规划管理,到三种核心导入场景(从库文件添加、从其他设计借用、处理第三方格式)的完整操作流程,并提供了导入后的关键验证清单与常见问题排查方法,旨在帮助硬件工程师快速掌握这一提升设计效率的关键技能。

weixin_29302047的博客 377

TI C2000 , .cmd文件,.TI.ramfunc,将程序分配为在RAM中运行/Flash运行的配置方法和原理讲解,(如28375S ,280049,28335等等芯片)

1 基础知识讲解 1.1 在RAM中运行还是在flash中运行指的是什么? 1.1.1 背景:程序编译完之后生成的.bin文件,.bin文件中包含代码段,代码段中全是汇编指令,而汇编指令中包含多个函数,各函数头的地址不同,如存在A函数和B函数,假设RAM地址区间是0x0000-0x8000,flash的地址区间是0xA000-0xF000,A函数要调用B函数,则A函数调用B函数的那段汇编指令中包含的是B函数头的存储地址,A函数和B函数都在flash中有存储 1.1.2 情况1:B函数是配置为在RAM中运行,

weixin_43776284的博客 8073

系统学习消息队列分享(三) 该如何选择消息队列?

聊一下几个比较常见的开源的消息队列中间件。如果你正在做消息队列技术选型,不知道该选择哪款消息队列,你一定要先听一下这节课的内容。 作为一个程序员,相信你一定听过“没有银弹”这个说法,这里面的银弹是指能轻松杀死狼人、用白银做的子弹,什么意思呢?我对这句话的理解是说,在软件工程中,不存在像“银弹”这样可以解决一切问题的设计、架构或软件,每一个软件系统,它都是独一无二的,你不可能用一套方法去...

weixin_30586085的博客 808

车规SoC深度对比:高通8397 vs 比亚迪D9000 vs 联发科CT-X1/MT8676/MT2715

芯片优势弱势最适合场景高通 8397低功耗、低延迟AI和音频处理单屏算力略低HUD + 音响座舱 + 低延迟交互D9000多屏渲染、Wi-Fi7高速通信AI算力中等高端多屏座舱 + 流媒体娱乐CT-X1极高AI算力、多模态渲染功耗较高高端沉浸式智能座舱 + 多摄像头感知MT8676算力均衡、座舱应用全面GPU稍弱全栈智能座舱、音视频多任务MT2715成本低、入门座舱可用算力低,低端显示入门智能座舱、基础信息娱乐。

weixin_43199439的博客 1774

Queue 开源项目使用教程

Queue 开源项目使用教程 项目介绍 Queue 是一个基于先进先出(FIFO)原则的开源队列实现项目。该项目旨在提供一个高效、易用的队列数据结构,适用于多种编程场景。Queue 项目支持多种编程语言,并提供了丰富的 API 接口,方便开发者进行集成和扩展。 项目快速启动 以下是一个简单的 Queue 项目快速启动示例,使用 Python 语言进行演示: # 安装 Queue 库 pip ins...

gitblog_00168的博客 491

FT2004(D2000)开发实战之网口stmmac报错调试(Failed to reset the dma)

网口stmmac报错调试(Failed to reset the dma)

嵌入式Linux 3587

Windows下超详细安装Anaconda3以及jupyter notebook

1.下载Anaconda安装包 Anaconda官网网站:https://www.anaconda.com/products/individual下载安装包速度比较慢,国内小伙伴不建议尝试。 我们可以使用清华大学开源软件镜像站:清华大学开源软件镜像站:https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/,请选择适合自己系统自行下载。 下载完成后如下图: 1.安装Anaconda安装包 1.打开安装包,点击Next 2.点击I Agre

m0_37957160的博客 3802

推荐开源项目:HTQ - 高效任务队列

推荐开源项目:HTQ - 高效任务队列 项目简介 是一个轻量级、高性能的任务队列系统,由 Go 语言编写。它设计的目标是帮助开发者轻松地管理后台异步任务,提升应用程序的响应速度和整体性能。在分布式系统中,HTQ 能有效地处理高并发场景下的任务调度问题。 技术分析 设计理念 简单易用:HTQ 的 API 简洁明了,使得集成到现有项目中变得非常容易。 高效:基于内存中的队列模型,HTQ 可以实现快速...

gitblog_00016的博客 624

【Unity大规模RTS/攻城战框架】Large Scale Combat System - RTS Sieges深度解析

本文介绍了Unity专业级大规模RTS战斗框架Large Scale Combat System(LSCS)。该系统通过Job System+Burst技术解决了万人级单位的性能问题,提供完整的RTS操作体系、动态阵型系统、战术AI和攻城战功能。其亮点包括可破坏城门、行走城墙、战术AI配置系统,支持URP渲染管线,适用于Total War风格的大规模兵团对战项目。LSCS不仅提供核心战斗系统,还包含UI、小地图等配套模块,是Unity中少有的专业级RTS解决方案,特别适合需要深度战术玩法和大规模战斗的开发者

2403_88403568的博客 1337

PhxQueue与Kafka/RabbitMQ对比分析:为何选择微信开源的分布式队列

在当今分布式系统架构中,**分布式消息队列**已成为微服务架构的核心组件。面对众多开源消息队列选择,微信开源的**PhxQueue**凭借其独特的设计理念和微信支付等核心业务的实际验证,成为高可靠场景下的优选方案。本文将深入分析PhxQueue与Kafka、RabbitMQ的差异,帮助您做出明智的技术选型决策。🚀 ## 📊 三大分布式队列核心特性对比 | 特性维度 | **PhxQueue

gitblog_00329的博客 888

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

PhxQueue深度解析:微信开源的高性能分布式队列如何支撑万亿级业务

**PhxQueue**是微信开源的一款基于Paxos协议实现的高可用、高吞吐和高可靠分布式队列系统,保证At-Least-Once Delivery(至少一次投递)。这个强大的分布式队列在微信内部广泛支持微信支付、公众平台等多个重要业务,每天处理着海量的消息队列任务。对于需要构建大规模分布式系统的开发者来说,PhxQueue提供了一个企业级的解决方案。 ## 🔥 为什么选择PhxQueue?

gitblog_01118的博客 1055

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

微信开源PhxQueue:高可用、高可靠、高性能的分布式队列**

消息队列概述 消息队列作为成熟的异步通信模式,对比常用的同步通信模式,有如下优势: 解耦:防止引入过多的 API 给系统的稳定性带来风险;调用方使用不当会给被调用方系统造成压力,被调用方处理不当会降低调用方系统的响应能力。 削峰和流控:消息生产者不会堵塞,突发消息缓存在队列中,消费者按照实际能力读取消息。 复用:一次发布多方订阅。 PhxQueue 诞生背景 旧队列 微信初期使用的分布式队列(称为旧队列)是微信后台自研的重要组件,广泛应用在各种业务场景中,为业务提供解耦、缓存、异步化等能力。 旧队列以

OpenIM的博客 388

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

PhxQueue快速入门指南:5分钟搭建你的第一个分布式队列系统

🚀 **分布式队列系统**是构建现代高并发应用的核心组件,而**PhxQueue**作为微信开源的一款基于Paxos协议实现的高可用、高吞吐和高可靠的分布式队列,能够保证At-Least-Once Delivery。在微信内部,PhxQueue广泛支持微信支付、公众平台等多个重要业务,是经过大规模生产验证的可靠解决方案。 ## 📋 PhxQueue核心特性速览 PhxQueue具备以下关键

gitblog_00020的博客 1056

phxqueue php,PhxQueue是微信开源的一款基于Paxos协议实现的高可用、高吞吐和高可靠的分布式队列...

PhxQueuePhxQueue is a high-availability, high-throughput and highly reliable distributed queue based on the Paxos protocol. It guarantees At-Least-Once Delivery. It is widely used in WeChat for WeChat...

weixin_36011746的博客 191

phxqueue java_phxqueue/README.zh_cn.md at master · Tencent/phxqueue · GitHub

PhxQueuePhxQueue是微信开源的一款基于Paxos协议实现的高可用、高吞吐和高可靠的分布式队列,保证At-Least-Once Delivery。在微信内部广泛支持微信支付、公众平台等多个重要业务。作者:Junjie Liang, Tao He, Haochuan Cui, Qing Huang and Jiatao Xu主要特性同步刷盘,入队数据绝对不丢,自带内部实时对账出入队严格有...

weixin_34170737的博客 157

PhxQueue部署完全手册:从单机测试到生产环境多节点部署

PhxQueue是微信开源的一款基于Paxos协议实现的高可用、高吞吐和高可靠的分布式队列,保证At-Least-Once Delivery。在微信内部广泛支持微信支付、公众平台等多个重要业务。本指南将帮助您从环境准备到生产部署,快速掌握PhxQueue的部署技巧。 ## 准备工作:环境与依赖安装 ### 系统要求 PhxQueue需要同时使用多个文件描述符。请保证设置`ulimit -Sn`

gitblog_01102的博客 987

phxqueue java_PhxQueue首页、文档和下载 - 基于 Paxos 协议的分布式队列 - OSCHINA - 中文开源技术交流社区...

PhxQueue 目前在微信内部广泛支持微信支付、公众平台等多个重要业务,日均入队达千亿,分钟入队峰值达一亿。其设计出发点是高数据可靠性,且不失高可用和高吞吐,同时支持多种常见队列特性。PhxQueue支持的特性如下:同步刷盘,入队数据绝对不丢,自带内部实时对账出入队严格有序多订阅出队限速出队重放所有模块均可平行扩展存储层批量刷盘、同步,保证高吞吐存储层支持同城多中心部署存储层自动容灾/接入均衡消...

weixin_26968079的博客 150

PhxQueue在微信支付中的实战应用:如何支撑海量交易请求的终极指南

在当今数字支付时代,微信支付每天需要处理数十亿笔交易请求,如何保证这些交易消息的可靠传输和高效处理成为了关键挑战。**PhxQueue分布式队列**作为腾讯微信团队开源的高可用、高吞吐消息队列系统,正是支撑这一海量业务场景的核心技术。本文将深入解析PhxQueue在微信支付中的实战应用,为您揭示这款基于Paxos协议的消息队列如何确保交易数据不丢失、不重复,并实现毫秒级响应。 ## 🔥 为什么

gitblog_01003的博客 418

PhxQueue容器化部署终极指南:使用Docker快速搭建分布式队列集群

PhxQueue是腾讯开源的一款基于Paxos协议的高可用、高吞吐、高可靠的分布式队列系统。它保证了至少一次交付(At-Least-Once Delivery),在微信支付、微信公众平台等腾讯重要业务中广泛应用。本文将为您提供完整的PhxQueue容器化部署教程,让您快速搭建分布式队列集群!🚀 ## 为什么选择PhxQueue容器化部署? **PhxQueue容器化部署**让分布式队列的搭建

gitblog_00034的博客 940

PhxQueue生产者使用完全指南:从基础API到高级批量优化

PhxQueue是微信开源的一款基于Paxos协议实现的高可用、高吞吐和高可靠的分布式队列系统。作为一款优秀的分布式队列解决方案,PhxQueue的生产者API设计简洁而强大,支持从简单消息投递到高级批量优化的多种使用场景。本文将为你提供PhxQueue生产者的完整使用指南,帮助你快速上手并优化生产环境中的消息投递性能。🚀 ## 📋 PhxQueue生产者核心概念 在开始使用PhxQueu

gitblog_00111的博客 952

phxqueue java_<<微信开源PhxQueue:高可用、高可靠、高性能的分布式队列>>的几个问题...

1.测试结果表格里面的kafka同步刷盘和异步刷盘,我认为不准确,会误导用户,因为同步刷盘意味着log.flush.interval.messages=1.而我的理解是文中想表达的是kafka消息同步复制和消息异步复制,即acks=-1和acks=1。因为producer的send()已经是异步发送消息了。入队 QPS(w/s)平均耗时(ms)PhxQueue(同步刷盘)1890Kafka(异步刷...

weixin_39901685的博客 135

如何在iPhone上运行Minecraft Java版:PojavLauncher三条安装路线上手

周六下午,你想在地铁上打两把《我的世界》,可App Store里只有基岩版——存档和电脑不互通,喜欢的模组装不上。PojavLauncher就是来解决这件事的:一个可侧载到iPhone、iPad上的开源Minecraft: Java Edition启动器,把启动器、Java运行时和图形栈整套打包,在手机上跑完整的PC版Java版,存档和模组直接沿用。 [![Minecraft Java版方块主题

gitblog_00621的博客 441
上一篇: 建设高并发系统的一些经验总结
下一篇: Spring事务在多线程下保证原子性
Jack爱258
博客等级 码龄10年 1288粉丝 124原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值