Fork me on Gitee

百万玩家实时排名怎么做?拆解 Google 从 SQL 到分片树与分桶近似的架构演进

一、排名系统到底在做什么?先用一个生活比喻建立直觉

想象你在一个十万人的考试现场,每交一份卷子,分数就会立刻变化。现在要求你随时回答:“张三目前排第几名?” 一个最直接的办法是:把所有人的分数从高到低排一遍,然后数一数张三名次。但当人数变成一百万,而且每秒有几百人改分数时,这个办法就会崩溃。

这就是排名系统的本质矛盾:数据在频繁变化,但你希望随时得到一个精确的名次。Google 的客户 Applibot 在游戏 Legend of the Criptids 中就遇到了这个问题:数十万玩家在线,玩家击倒敌人分数就会变,每次变化都要能快速查到新排名。

一个合格的系统需要同时满足几件事:

  • 快:查询排名和更新分数都要在数百毫秒内完成;
  • 准:不能返回过期或错误的排名;
  • 扛得住并发:每秒可能有三四百次分数更新;
  • 能扩展:玩家从十万涨到百万甚至更多,系统不能直接崩掉。

接下来我们会看到,Google 的工程师正是围绕这四个目标,一层一层地把方案从“能跑”推进到“能扛”。

二、第一层:最朴素的想法,以及它为什么必然失败

2.1 直接查数据库

最直观的做法,是在数据库里执行一句 SQL:

SELECT COUNT(*) FROM Players WHERE Score > 我的分数;

这句查询的含义是:数一数有多少人的分数比我高,比我高的人有几个,我就是第几名加一。

这个方案在数据量小的时候完全没问题,但它有一个致命缺陷:每次查询都要扫描大量数据。用算法语言说,它的时间复杂度是 O(n)——玩家数量翻一倍,查询时间大致也翻一倍。当玩家达到百万级,每次排名查询都做一次全表扫描,数据库会立刻成为瓶颈。文章提到,最初这个查询要花几秒钟才返回,在游戏中这是不可接受的。

2.2 用缓存救急

自然的第二反应是:把排名结果放进内存缓存,比如 Memcache,读的时候就不查数据库了。

但缓存有两个根本问题。第一,内存数据可能随时被淘汰或丢失,Memcache 本身并不保证持久性;第二,分数在不停变化,缓存必须频繁失效,否则返回的就是旧排名。排名系统对“准”的要求很高,靠缓存兜底是兜不住的。

2.3 定时批量计算

第三个退路是:不实时算了,每小时跑一次批处理,把所有人排名算好存起来。这样查询确实快了,但排名会有一个小时的延迟。对于竞技游戏,一小时的延迟基本等于排名系统不存在。

这三个方案暴露出同一个问题:O(n) 的查询在百万级用户下不可接受,而缓存和定时批处理又牺牲了准确性。必须换数据结构。

三、从 O(n) 到 O(log n):树结构为什么是转折点

3.1 核心思路:不要让每次查询都数一遍所有人

如果玩家按分数组织成一棵有序的树,那么每次查询就不需要扫描全部数据,而是从树根沿着一条路径走下去,只访问 log₂n 个节点。一百万个玩家,log₂n 大约是 20 次比较——从“数一百万人”变成“比较二十次”,这就是质变。

3.2 什么样的树能回答“第几名”?

普通的二叉搜索树只能回答“某个分数在不在树里”,但不能直接回答“这个节点排第几”。解决办法是给每个节点额外记录一个信息:它的左右子树各有多少个节点。

有了这个“子树大小”,排名就可以通过一条从节点到根的路径计算出来:

  • 如果当前节点是父节点的右孩子,说明父节点和父节点的整棵左子树都排在它前面,把“父节点左子树大小 + 1”累加;
  • 一路向上,累加的值就是比它大的元素数量;
  • 排名 = 累加值 + 1。

用伪代码表示:

function getRank(node):
    rank = node.left.size + 1          // 左子树全部在它前面,加上自己
    current = node
    while current.parent != null:
        if current is rightChild of current.parent:
            rank += current.parent.left.size + 1
        current = current.parent
    return rank

这就是“扩充的二叉搜索树”(Augmented BST)思路,每个节点维护 size,插入、删除、查排名都是 O(log n)。

3.3 哈希表 + 树:两条腿走路

树负责“按分数排序并支持排名计算”,但系统还需要能通过玩家 ID 快速找到对应的分数节点。所以实际结构是:

哈希表:  playerId → 分数节点(指针)
          ↓
二叉平衡树:  节点按分数排序,每个节点记录 left.size 和 right.size

查询某个玩家的排名时:先用哈希表 O(1) 找到节点,再沿树向上 O(log n) 算排名。更新分数时:哈希表改指针,树中删除旧位置、插入新位置,同样是 O(log n)。

3.4 为什么不用堆?

堆也能快速找最大或最小,但“找第 k 名”需要把 k 个元素逐个弹出再塞回去,对于频繁更新的场景非常不友好。排名系统需要的是“任意分数随时查排名”,而不是“反复取最大值”,所以平衡树比堆更合适。

到这里,算法层面的问题基本解决了:单机、低并发下,O(log n) 的树结构可以在数百毫秒内完成排名查询和分数更新。但工程上的真正麻烦才刚刚开始。

四、工程第一道坎:树放在 Datastore 里,每秒只能写一次

4.1 Datastore 的事务边界

Google 的方案把树结构持久化在 Datastore(App Engine 的强一致 NoSQL 数据库)里。为了保证树的一致性,每次更新都必须在一个事务中完成,否则并发修改可能把树结构改坏。

但 Datastore 有一个硬性限制:同一个实体组(entity group)的写入吞吐大约只有每秒 1 次事务。这意味着,即使树算法本身是 O(log n),底层存储根本撑不住每秒几百次更新。

文章里提到,压力测试时把请求提高到每秒 3 次更新,系统就开始报错了,而 Applibot 的目标是每秒 300 次。这就是典型的“算法对了,但存储引擎拖后腿”。

4.2 用“任务合并”把多次写压成一次事务

Datastore 团队给出的思路是:不要每次 SetScore 都单独开事务,而是把多个更新攒在一起,一次事务批量执行。一次事务里写入多个玩家,既减少了事务次数,又利用了 Datastore 对批量写入的支持。

具体做法引入了一个队列:

前端 SetScore 请求
        ↓
   队列(存放待更新的玩家+分数)
        ↓
后端单线程循环:从队列取出多条任务
        ↓
   合并成一次 Datastore 事务

单线程的作用很关键:没有并发,就不需要处理并发冲突。文章原话是,“使用单线程在一次事务中按顺序执行这些更新,既然单线程,就不会有并发冲突的问题”。

这个方案把写入能力提高到了每秒约 200 次更新,每次事务合并 500 到 600 次更新。虽然还没到 300,但方向已经对了。

4.3 队列分片:解决 Bigtable 分片时的“卡顿”

单队列方案运行几分钟后,吞吐量会出现周期性大幅波动。原因不在业务逻辑,而在队列的底层存储 Bigtable:当某个分片过大时,Bigtable 会进行分片(split),分片过程中该分片上的任务不会被分发,队列就“卡住”了。

解决办法是把任务分散到多个队列:

SetScore 请求
   ↓
10 个队列(每个最多约 1000 个任务)
   ↓
SetScores 方法批量取出并合并
   ↓
后端单线程事务执行

这样即使一个队列因为分片暂时不可用,其他队列仍然能继续供任务,系统整体不会停摆。最终这套方案稳定支撑了每秒 300 次更新,满足了 Applibot 的要求。

五、工程第二道坎:单线程事务的天花板与分片树

5.1 单线程的天花板在哪里

“任务合并 + 单线程事务”虽然解决了并发冲突,但也把吞吐量锁死在一个线程处理事务的速度上。文章明确把“吞吐量有限,只能支持约每秒 300 次更新”列为这个方案的主要缺点。

如果游戏更火爆,每秒需要 3000 次甚至 30000 次更新,单线程事务显然不够。

5.2 把树切成多棵,排名相加

扩展思路非常巧妙:既然一棵树只能由一个线程串行更新,那就把玩家分成多组,每组一棵独立的树,每组有自己的队列和更新线程。比如分成三棵树,理论上写入吞吐可以提升三倍。

但分片之后,查询排名不能再只看一棵树。一个分数在每棵树里都有一个“本树排名”,它代表这棵树里有多少人比它高。全局排名就是三棵树的局部排名之和:

FindRank(865)
   Tree A 局部排名:124
   Tree B 局部排名:183
   Tree C 局部排名:156
   全局排名 = 124 + 183 + 156 = 463

文章给出的例子正是这样:分数 865 在三棵树中分别排 124、183、156,所以全局排第 463 名。

这个“排名可相加”的性质不是所有系统都具备的,但排名恰好满足,所以分片树方案成立。代价是查询时要并行(或依次)查多棵树再求和,系统复杂度上升。

六、另一条路线:不要精确,要“足够好的近似”

6.1 为什么近似是合理的

精确排名在百万级用户下需要维护一棵复杂的树,工程成本很高。但很多场景并不需要“绝对精确到个位”。比如游戏排行榜,用户看到“第 100 名”还是“第 103 名”,体验差别并不大。如果能把误差控制在 1% 左右,换来数量级的性能提升,很多产品会接受。

文章讨论了两类近似思路,这里重点展开更工程友好的 Buckets with Global Query(分桶 + 全局查询)。

6.2 分桶法的直觉:把分数切成区间

假设分数范围是 0 到 99,把它分成 4 个桶:

[0, 24]  [25, 49]  [50, 74]  [75, 99]

每个桶记录两个关键信息:

  • 这个区间里有多少人;
  • 这个区间内最高分的全局排名。

当你要查一个 60 分的人的排名时,先找到它落在 [50, 74] 桶。这个桶的最高分是 74,74 的全局排名已知是第 5。桶里一共有 42 个人。假设分数在桶内均匀分布,那么 60 分大约位于桶内 (74 - 60) / (74 - 50) = 14/24 的位置。于是:

估计排名 ≈ 5 + 42 × (14 / 24) ≈ 5 + 24.5 ≈ 30

文章中的公式是 rank = 5 + (74 - 60) × 42 / (74 - 50) = 30,思路完全一致。

6.3 这个方案的性能特征

  • SetScore 和 FindRank 都是 O(1):更新分数只需要改哈希表,查排名只需要读对应桶的数据,计算量固定。
  • 桶的“频率”和“最高排名”由后台的 global query 定时重算。在百万用户量级,文章提到一次全局计算大约 8 分 34 秒,远快于“逐个玩家算精确排名”的小时级批处理。
  • 因为用户更新分数时不需要同步更新桶数据,所以可以承受很高的并发写入。

6.4 准确率到底怎么样

文章给出了实测数据:在 1 万名玩家、分数均匀分布 [0, 9999] 的条件下,即使只用 5 个桶,错误率也在 1% 左右。在高排名区间准确率会下降,因为高分段人数少,均匀分布假设不再成立;解决办法是对头部玩家单独用更精确的结构维护,而头部人数很少,额外开销可以接受。

另一个近似算法 Lossy Counting 走的是“数据流频率统计”路线:把数据分成窗口,每处理一个窗口就把哈希表中所有计数减 1,计数归零的元素删除。这样只需要维护“频繁出现的分数”的近似频率,内存占用远小于全量哈希表。它的代价是适用于分数分布集中的场景,如果每个玩家分数都不同,效果会退化。这里不展开伪代码,只需理解:近似算法的选择高度依赖数据分布,没有一种近似能通吃所有场景。

七、把整条演进路线串起来看(架构演进图)

阶段 0:SQL COUNT
         O(n),百万用户不可用
              ↓
阶段 1:哈希表 + 二叉平衡树(子树 size)
         O(log n),单机算法正确,但 Datastore 事务限制写入
              ↓
阶段 2:队列 + 任务合并 + 单线程事务
         解决并发冲突,吞吐约 300 更新/秒
              ↓
阶段 3:多队列
         解决 Bigtable 分片导致的队列卡顿
              ↓
阶段 4:分片树
         多棵树并行更新,排名相加,突破单线程天花板
              ↓
分支路线:分桶 + Global Query / Lossy Counting
         放弃绝对精确,换取 O(1) 读写和高并发

这张图里每一层都不是“为了炫技”,而是被前一层暴露出的真实瓶颈逼出来的。这也是系统设计最值得学习的地方:先让方案在真实约束下跑起来,测量它,找到瓶颈,再引入新的机制。

八、如果换成“看板系统”,排序问题和排名问题有什么不同?

虽然原文讲的是排名,但你最初点进来可能期待的是“Board/看板”。这里用一小节做一个对照,帮助你区分两类“排序”问题的工程思路,也算对“board”这个词做一个回应。

看板(如 Trello、Jira)里也涉及排序:卡片在列内和列间拖拽,顺序需要持久化。但它和排名系统的核心差异是:

维度 排名系统 看板排序
排序对象 所有玩家的分数,全局有序 卡片在某一列内的相对位置
更新模式 分数频繁变化,排名全局漂移 拖拽是低频人工操作
核心难点 高并发更新 + 精确/近似全局排名 拖拽后只改少数记录,不重排全部
典型方案 平衡树 / 分桶 / Redis Sorted Set LexoRank 等“两值之间取中间值”的字符串排序

看板系统常用 LexoRank 这类方案:每张卡片有一个字符串 rank,插入到两张卡片之间时,算法生成一个字典序严格位于两者之间的新字符串,只更新被拖拽的那一行,不需要把整列重新编号。Jira 就用 LexoRank 来排序 issue。这和排名系统“每次分数变化都要重新确定全局名次”的压力模型完全不同——看板的排序更新是稀疏的,排名的更新是稠密的。

九、给研发小白的几个关键 takeaway

第一,时间复杂度不是纸面概念,它直接决定产品能不能用。 O(n) 的 COUNT 查询在演示环境跑得通,到了百万用户就是灾难;O(log n) 的树把“数所有人”变成“走一条路径”,是排名系统能实时响应的算法基础。

第二,算法正确不等于工程可行。 平衡树的 O(log n) 很漂亮,但 Datastore 每秒 1 次事务的硬限制让它在高并发下直接失效。真正的系统设计必须把存储引擎的约束当作一等公民。

第三,队列 + 合并 + 单线程是一种经典的“用串行换一致”模式。 它牺牲了并行写入的吞吐上限,换来了无并发冲突的简单性和强一致性。当单线程成为天花板时,再通过分片把串行单元拆成多个,用“排名相加”恢复全局视图。

第四,近似不是妥协,是另一种工程权衡。 当精确性的边际成本急剧上升时,把误差控制在可接受范围内,可以换来数量级的性能提升。但近似算法的适用性依赖数据分布,选型前必须理解你的数据长什么样。

第五,系统设计是一个“测量—瓶颈—演进”的循环,不是一次画完的终稿。 原文最精彩的地方不是最后那套架构图,而是它展示了每一步为什么要改:事务限制逼出合并,合并的天花板逼出分片,分片又带来排名相加的新问题。你以后做任何系统,都可以用同样的方式思考:先跑起来,测它,找到最疼的那个约束,再动手。

参照学习地址:Google 是如何设计排名系统的

posted @ 2026-10-21 23:00  JoePotter  阅读(8)  评论(0)    收藏  举报
``