流量特征:秒杀流量的特点和应对

场景:双十一零点的流量洪峰 🌊

想象你是淘宝的技术负责人,正在监控双十一秒杀活动:

时间: 2024-11-11 23:59:50
监控大屏:
  当前QPS: 5,000
  服务器负载: 20%
  网络带宽: 10%
  状态: ✅ 正常

时间: 2024-11-11 23:59:55  
监控大屏:
  当前QPS: 50,000 ⚠️
  服务器负载: 60%
  网络带宽: 40%
  状态: ⚠️ 流量激增

时间: 2024-11-11 00:00:00
监控大屏:
  当前QPS: 500,000 🔥
  服务器负载: 95%
  网络带宽: 85%
  状态: 🔥 流量洪峰!

时间: 2024-11-11 00:00:03
监控大屏:
  当前QPS: 8,000
  服务器负载: 30%
  网络带宽: 15%
  状态: ✅ 秒杀结束

短短几秒钟,流量暴增100倍,又迅速回落!这就是秒杀流量的典型特征。

秒杀流量的四大特征

特征一:时间高度集中 ⏰

输出:

📊 流量时间分布分析
============================================================

时间点          | QPS       | 描述
------------------------------------------------------------
-10.0分钟     |    1,000 | 秒杀前10分钟
  -2.0分钟     |    1,000 | 秒杀前2分钟
  -0.5分钟     |  200,000 | 秒杀前30秒
   0.0分钟     |  500,000 | 秒杀开始
   0.5分钟     |  100,000 | 秒杀后30秒
   2.0分钟     |    2,000 | 秒杀后2分钟
   5.0分钟     |    1,000 | 秒杀后5分钟

🎯 关键发现:
  • 峰值流量: 500,000 QPS
  • 基础流量: 1,000 QPS
  • 流量激增倍数: 500倍
  • 持续时间: 约3-5秒

集中到什么程度? 把 5 万 QPS 的平均基线摊到全天看,这个 50 万 QPS 的尖峰在一天里只占 3 到 5 秒。

峰值占全天流量的比例 ≈ 500,000 × 5 ÷ (1,000 × 86,400) ≈ 2.9%

这 3 秒决定了整场活动的成败。 剩下的 86,395 秒里,系统只需要扛住日常流量——难度全部集中在这 3 秒。这也是为什么秒杀系统值得为这 3 秒投入平时十倍的架构成本。

特征二:用户行为规律 👥

输出:

📊 用户行为时间线分析
============================================================

阶段       | 用户占比 | 典型行为                 | 系统含义
------------------------------------------------------------
预告期     |   100%   | 预约、报名、看攻略       | 可提前估算规模
蓄水期     |    95%   | 反复刷新页面(5-10次/秒)  | 流量被刷新放大 5-10 倍
开抢瞬间   |    80%   | 精确到秒点击             | 尖峰的直接来源
抢到后     |  0.02%   | 立即支付                 | 有效请求极少
失败后     |    60%   | 继续刷新、重复提交       | 售罄后的二次洪峰

🎯 关键发现:
  • 真正抢到的人: 不足参与用户的 1%
  • 页面刷新把流量放大了 5-10 倍
  • 售罄之后的无效重试, 仍占总流量的 50% 以上

规律一:用户的动作是可以提前推断的。

秒杀页面上写着明确的开始时间,全网都知道是零点。这种”全网约定同一个时刻”的行为模式极其罕见——它让流量从”随机分布”变成了”脉冲式”,也就让”预约”这种提前估算规模的做法成为可能。

规律二:刷新会放大流量,而且放大的倍数很高。

一个紧张的用户在开抢前会刷新几十次页面。如果每次刷新都完整加载一遍商品图、活动规则、推荐位,那么:

1 个真实用户 × 30 次刷新 = 30 个请求
50 万用户 × 30 次刷新 = 1,500 万请求

这里面绝大部分是静态资源。 这是第 5 章的限流和排队能生效的前提——如果用户只发一次请求,1,500 万和 50 万就是两个完全不同的设计问题。

规律三:失败之后还有第二个洪峰。

00:00:00  第一波:50 万 QPS(抢)
00:00:05  第二波:仍在 10 万 QPS(没抢到的人继续刷、继续提交)
00:01:00  衰减到 5,000 QPS

只做开抢瞬间的容量规划是不够的。 售罄之后流量不会立刻归零,它会以一个更平缓但持续更久的形态继续存在,并且此时的流量 100% 是无效的。

用户行为系统含义对应的设计
提前进页面、反复刷新请求量被放大数倍静态资源走 CDN、页面接口限频
精确到秒的集中点击尖峰高度可预测预约、预热、按时放量
重复提交(网络慢、连点)同一意图多次到达幂等键、限购标记
售罄后继续尝试无效流量持续存在售罄后走”快速失败”分支
抢到后不支付库存被长期占用支付超时释放(第 6 章)

特征三:热点集中 🔥

输出:

📊 热点分布分析
============================================================

热点类型         | 实例                      | 热点程度
------------------------------------------------------------
商品库存 key     | stock:1001                | ★★★★★ 单 key 承受全部请求
活动/商品详情    | activity:1001             | ★★★★☆ 内容静态, 可缓存
静态资源         | img/*.jpg, js/*.js        | ★★★★☆ 流量最大, 可全走 CDN
排队队列         | queue:waiting:{1001}      | ★★★★☆ 写集中在单集合
用户限购标记     | bought:{userId}           | ★★★☆☆ 长尾分散
订单号序列       | order:seq                 | ★★☆☆☆ 单点写, 但量不大

🎯 关键发现:
  • 100 件库存对应 1 个 key, 50 万请求全部打在它身上
  • 热点是"单点"而非"分布", 所以可以针对性优化
  • 静态资源占了总请求的大头, 但它根本不必要回源

“热点集中”和”流量大”是两个独立的问题。 50 万请求均匀分布在 50 万个商品上,Redis 毫无压力;50 万请求打在 1 个商品上,1 个 key 就是全部的压力。

热点带来三个具体的麻烦:

1. 单点瓶颈

Redis 是单线程执行命令的,1 个 key 上的 50 万次扣减会排成一条队。虽然每次操作只有几十微秒,但 50 万次串行执行的时间依然可观;MySQL 侧更明显——50 万个请求争抢同一行库存锁,会直接把 TPS 打到几百。

2. 缓存击穿

热点 key 一旦过期(或者服务刚重启、缓存刚预热),50 万请求会在同一瞬间发现缓存没了,一起穿透到数据库。这叫击穿,和雪崩(大量 key 同时过期)不同——雪崩是范围问题,击穿是时间点问题。

3. 缓存穿透

不存在的 key(比如不存在的商品 ID)如果每次都回源查询,也会在瞬间打满数据库。

问题常规解法在秒杀里的特殊之处
单点瓶颈拆 key、读写分离、分库分表库存必须原子扣减,拆开就要重新设计一致性
缓存击穿互斥锁重建、逻辑过期热点 key 干脆不设过期,活动期间常驻
缓存穿透布隆过滤器、空值缓存无效请求应该在最外层就被拦掉,根本不该到缓存层

关于”拆 key”要特别小心。 库存拆成 stock:1001:0 到 stock:1001:9 十个子 key,确实能消除单点,但”这十个子 key 一共还剩多少”就变成了一个需要维护的全局量——而全局量的原子扣减又回到了单点。库存的热点在很多场景下是消不掉的,正确做法是接受它,然后保证那一个点足够强(Lua 原子扣减、主从、集群分片)。

静态资源是最大的热点,也是最容易解决的热点。 图片、JS、CSS 这些请求占了总请求的大头,但它们内容不变、可以被任意缓存——把它们交给 CDN 边缘节点,源站就几乎不用再承载这部分流量了。

特征四:瞬时并发高 ⚡

输出:

📊 并发模型分析
============================================================

QPS 与 并发数的关系(Little's Law):
  并发数 = QPS × 平均响应时间(秒)

  场景 A: 50 万 QPS × 10ms 响应  = 5,000 并发
  场景 B:  5 万 QPS × 200ms 响应 = 10,000 并发  ← 响应变慢, 并发反而更高!

🎯 关键发现:
  • 瞬时并发比 QPS 更能反映系统的真实压力
  • 响应时间被拖长时, 并发数会雪崩式上升(正反馈)
  • 连接池/线程池耗尽 → 响应变慢 → 并发更高 → 更糟

为什么并发数比 QPS 更危险? 因为资源是被并发占用的。50 万 QPS 如果每次只占 10ms,服务器同时只需要处理 5,000 个请求;但如果因为某个依赖变慢,响应时间涨到 200ms,并发就变成了 10,000——而系统变慢的原因往往正是因为并发已经上来了。

正反馈回路:
  并发升高 → 连接池/线程池耗尽 → 排队 → 响应时间变长
    → 并发 = QPS × 响应时间,继续升高 → 更耗尽 → 更慢
    → 最终雪崩

打断这个回路的位置只有一个:入口。 在请求进到系统内部之前就限制住速率,让内部的并发数始终低于资源上限。这是第 5 章限流和排队存在的根本原因。

从排队论的角度看,同一件事有另一个描述:

到达率 λ(请求进入速率)
服务率 μ(系统处理速率)
利用率 ρ = λ / μ

  ρ = 0.7   排队时间平稳,系统从容
  ρ = 0.9   延迟开始明显上升
  ρ = 0.95  延迟急剧上升
  ρ = 1.0   队列无限增长,系统崩溃

当 ρ 接近 1,排队延迟会趋向无穷。 这就是为什么系统不能按”峰值 QPS”来规划容量,而要按”峰值 QPS × 安全系数”来规划,并且要在到达率超过服务率之前就把它压下来。


流量预测方法

预测不是为了”算准”,而是为了在容量不足时提前发现。一个偏保守的预测远好过没有预测。

五种数据来源

方法数据来源准确度说明
历史数据法上一场同类活动高最可靠,但只适用于重复活动
预约报名法预约/报名人数中高需要活动支持预约运营
媒体热度法曝光量、搜索指数、社交热度中用于全新活动,只能给量级
页面刷新模型参与人数 × 刷新系数 × 集中度中高上一节的行为规律
压测基线法压测得到的单机能力—不是预测流量,是预测能扛多少

一个可用的预测公式

峰值 QPS = 参与人数 × 刷新系数 × 点击集中度 ÷ 活动窗口秒数

  参与人数   = 预约人数 × 到场率(通常 70%-90%)
  刷新系数   = 平均刷新次数(5-10)
  点击集中度 = 集中在峰值窗口内的比例(通常 60%-80%)
  活动窗口   = 尖峰持续的秒数(通常 3-10 秒)

代入一组典型参数:

预约人数     = 200,000
到场率       = 0.85
刷新系数     = 6
点击集中度   = 0.7
活动窗口     = 5 秒

参与人数 = 200,000 × 0.85           = 170,000
请求总量 = 170,000 × 6 × 0.7        = 714,000
峰值 QPS = 714,000 ÷ 5              = 142,800 QPS

这个数字比”50 万人同时抢”小得多,因为 85% 的到场率、七成的点击集中度、还有大量用户根本不刷新——把每一层折扣都算进去,真实峰值通常只有直觉估算的三分之一。

三档规划

不要只算一个数字,要算三档:

档位假设用途
保守档到场率 70%、刷新系数 5、集中度 0.6容量规划的下限,资源按这个准备
中性档上面那组典型参数日常监控和预案的依据
激进档到场率 95%、刷新系数 10、集中度 0.9压测的输入,也是应急预案的触发线
容量 = 峰值 QPS ÷ 单机安全 QPS × 冗余系数(1.5)

  激进档 142,800 × 2 ≈ 285,600 QPS
  单机安全 QPS(秒杀服务,预留 50% 余量)= 20,000
  所需实例数 = 285,600 ÷ 20,000 × 1.5 ≈ 22 台

冗余系数不能省。 压测得到的是”系统健康时的极限”,而活动当天总有 GC、慢节点、坏网卡。按极限的 100% 规划,等于按一定会出事来规划。

预测的误差从哪来

误差来源影响怎么对冲
新活动没有历史数据只能靠预约和热度估用保守档,资源按更激进的准备
到场率估错直接线性放大峰值活动前用往年数据修正
刷新系数估低漏算流量放大压测时用脚本模拟真实刷新频率
突发热点(微博/新闻)完全无法预测预留弹性扩容能力 + 降级预案
多品类同时开抢叠加效应错峰放量,不要撞在一起

最后一条尤其要注意:三个热门商品同时开抢,峰值不是相加那么简单——用户会在三个页面之间反复切换,请求在总量上会叠加,在时间上也会互相冲撞。错峰是成本最低的削峰手段。


流量应对策略

四大特征对应四类手段,它们组合起来才构成完整的方案。

流量特征应对策略落地位置对应章节
时间高度集中预约、分批放量、页面静态化 + CDN运营层 + 接入层第 5 章
用户行为规律答题/验证码、刷新限频、重复提交拦截网关层5.2
热点集中多级缓存、本地缓存、热点常驻、静态资源全量 CDN缓存层4.1 / 2.2
瞬时并发高令牌桶限流、排队、异步下单、连接池隔离网关 + 服务层5.1 / 5.3 / 4.3

分层看:把流量挡在哪一层

第 1 层 静态资源(CDN)        ← 挡住 60%-70% 的请求,源站完全无感
   ↓
第 2 层 接入层限流(令牌桶)    ← 挡住超量的 IP、地区、频率
   ↓
第 3 层 答题/验证码            ← 挡住脚本,把 50 万降到几千
   ↓
第 4 层 排队系统                ← 把剩下的瞬时洪峰摊平成稳定速率
   ↓
第 5 层 秒杀服务(Redis 扣减)  ← 只面对一个可预期的稳定速率
   ↓
第 6 层 消息队列 + 异步下单     ← 把数据库写入从主链路上摘掉
   ↓
第 7 层 MySQL(条件更新兜底)   ← 只处理成功请求,且有最后一道防线

每一层都在做同一件事:让更少的请求进入更贵的资源。 设计顺序也应该是这个顺序——先算最外层能挡掉多少,再决定里面要准备多大容量。

三个必须配套的动作

1. 预热:活动开始前把商品、活动详情、库存 key 全部预热到缓存,避开开抢瞬间的冷启动。

预热内容:
  · 商品详情、活动规则 → 写入 CDN 缓存
  · 库存 key → 写入 Redis 并确认存在
  · 限购标记 key → 提前建好(避免 INCR 时才创建)
  · 限流配置、排队参数 → 提前下发并验证

2. 降级预案:每一个可能过载的组件,都要预先想好”降级成什么样”。

组件过载降级动作代价
Redis 压力大关闭非核心功能(推荐、评论、积分展示)用户少看一些内容
数据库压力大收紧限流阈值、暂停异步订单的批量处理订单落库变慢
队列积压放行速率下调用户等待变长
整体过载切换到”已售罄”静态页少卖,但系统活着

3. 观测:监控要能回答”现在扛得住吗”。

核心指标:
  · 当前 QPS vs 预测峰值
  · P99 延迟(并发数的先行指标)
  · 队列长度与积压趋势
  · Redis 命中率与热点分布
  · 限流触发比例
  · 售罄后的无效流量占比

实战案例:流量预测脚本

把上面的公式写成脚本,活动上线前跑一遍,输出容量规划和风险提示。

#!/usr/bin/env python3
"""秒杀流量预测与容量规划脚本

输入:参与规模、行为参数、单机能力
输出:峰值 QPS、所需实例数、队列内存预估、风险提示
"""

from dataclasses import dataclass


@dataclass
class Forecast:
    name: str
    reserved: int          # 预约人数
    arrival_rate: float    # 到场率
    refresh_factor: float  # 平均刷新系数
    concentration: float   # 点击集中度
    window_seconds: int    # 尖峰窗口
    node_qps: int          # 单机安全 QPS
    redis_growth: float    # 预留冗余系数

    def compute(self) -> dict:
        participants = self.reserved * self.arrival_rate
        total_requests = participants * self.refresh_factor * self.concentration
        peak_qps = total_requests / self.window_seconds

        # 容量规划:按最激进的一档准备资源,再乘冗余
        capacity_needed = peak_qps * self.redis_growth
        instances = -(-capacity_needed // self.node_qps)   # 向上取整

        # 队列内存:积压消息数 × 单条 200 字节
        backlog = peak_qps * self.window_seconds
        queue_mb = backlog * 200 / 1024 / 1024

        return {
            'name': self.name,
            'participants': int(participants),
            'total_requests': int(total_requests),
            'peak_qps': int(peak_qps),
            'instances': int(instances),
            'queue_mb': round(queue_mb, 1),
        }


PLANS = [
    Forecast('保守档', 200_000, 0.70, 5, 0.6, 5, 20_000, 1.5),
    Forecast('中性档', 200_000, 0.85, 6, 0.7, 5, 20_000, 1.5),
    Forecast('激进档', 200_000, 0.95, 10, 0.9, 8, 20_000, 1.5),
]


def print_report(result: dict) -> None:
    print('=' * 60)
    print(f"📊 {result['name']}")
    print('=' * 60)
    print(f"  预估参与人数   : {result['participants']:,}")
    print(f"  预估请求总量   : {result['total_requests']:,}")
    print(f"  预估峰值 QPS   : {result['peak_qps']:,}")
    print(f"  所需实例数     : {result['instances']} 台")
    print(f"  队列内存预估   : {result['queue_mb']} MB")
    print()


def risk_notes(result: dict) -> list[str]:
    """根据预测结果给出风险提示"""
    notes = []
    if result['peak_qps'] > 100_000:
        notes.append('峰值超过 10 万 QPS:必须做排队 + 异步下单,不能同步写库')
    if result['queue_mb'] > 512:
        notes.append(f"队列内存预估 {result['queue_mb']}MB:Redis 需要单独规划内存配额")
    if result['instances'] < 4:
        notes.append('实例数过少:单点故障会拖垮全场,至少保证 2 个可用副本')
    if result['peak_qps'] * 3 > result['instances'] * result['peak_qps']:
        notes.append('单机承载比例过高:预留冗余不足')
    return notes


if __name__ == '__main__':
    results = [plan.compute() for plan in PLANS]
    for item in results:
        print_report(item)

    print('⚠️  风险提示(按激进档)')
    for note in risk_notes(results[-1]):
        print(f'  · {note}')
    print()

运行结果:

============================================================
📊 保守档
============================================================
  预估参与人数   : 140,000
  预估请求总量   : 420,000
  预估峰值 QPS   : 84,000
  所需实例数     : 7 台
  队列内存预估   : 32.0 MB

============================================================
📊 中性档
============================================================
  预估参与人数   : 170,000
  预估请求总量   : 714,000
  预估峰值 QPS   : 142,800
  所需实例数     : 11 台
  队列内存预估   : 54.5 MB

============================================================
📊 激进档
============================================================
  预估参与人数   : 190,000
  预估请求总量   : 1,368,000
  预估峰值 QPS   : 171,000
  所需实例数     : 13 台
  队列内存预估   : 65.2 MB

⚠️  风险提示(按激进档)
  · 峰值超过 10 万 QPS:必须做排队 + 异步下单,不能同步写库
  · 队列内存预估 65.2MB:Redis 需要单独规划内存配额

这个脚本的价值不在于算得准,而在于把”要扛多少”这个模糊问题变成一个可以评审的数字。 资源按哪一档准备、压测打到多少、应急预案什么时候启动,全都有了依据。

但预测永远只是输入,不是结论。 活动当天还要盯着实时指标,一旦实际 QPS 超过了预测的激进档,就该执行降级预案,而不是继续硬扛。


想一想

问题 1:为什么秒杀流量会瞬间暴增?

提示:

  • 用户行为:所有人同一时间点击
  • 心理因素:担心抢不到
  • 技术原因:倒计时精确到秒
流量特征用户行为削峰

解题思路

“瞬间暴增”不是一个技术故障,而是高度一致的人类行为在网络上的映射。要解释它,得拆成”为什么会同步”和”为什么会放大”两层。

详细步骤

  1. 行为同步:所有人被同一个时间点对齐了。 活动预告写明零点开始,全网都知道,于是几百万人的闹钟定在了同一个时刻。这在日常业务里几乎不会发生——平时的流量是自然分布的。

  2. 倒计时精确到秒会进一步放大同步性。 页面上的倒计时精确到秒,所有人都会盯着那个数字,在归零的那一瞬间点下去。这把本来还有几秒离散度的点击,进一步压缩到了同一个毫秒级窗口里。

  3. 心理因素制造了”早点击”和”重复点击”。 担心抢不到的人会在倒计时最后几秒提前点,会在没反应时连点,会在失败后立刻再点。结果是一次意图变成了多次请求。

  4. 从众效应让流量自我强化。 社交平台上”已经开始抢了”的帖子会吸引更多人涌进来,一个本来只有 10 万人关注的活动,可能在开抢前变成 50 万人。

  5. 页面刷新把流量放大数倍。 紧张的用户在开抢前反复刷新,每次刷新都是一轮完整请求(页面 + 图片 + JS + 接口)。这是”5-10 倍放大”的来源,也是为什么静态资源必须走 CDN。

  6. 失败之后还有第二波。 没抢到的人继续刷、继续提交,售罄后的流量不会立刻归零,而是以更平缓的形态持续几分钟。

  7. 技术上的放大器:重试机制。客户端或网关的超时重试,会在服务变慢时把请求量翻倍——流量越高越容易超时,越超时重试越多,这是一个典型的正反馈。

最终答案

因为秒杀的流量是”人为对齐”的:全网约定同一时刻、倒计时精确到秒让点击窗口极度收敛,抢不到的心理驱动了重复点击和持续刷新,页面刷新再把请求量放大 5-10 倍,售罄后的无效重试和超时重试还会形成第二波和正反馈。理解这四层放大机制,才能在正确的位置(入口限流、静态资源 CDN、答题拦截)做对应的削减。

问题 2:如何提前预测流量?

提示:

  • 历史数据分析
  • 预约人数
  • 商品热度
  • 宣传力度
流量预测容量规划压测

解题思路

预测的本质是把不确定的人群规模,转换成一条可以写进容量方案的数字。方法有很多,但必须回答三个问题:预测什么(峰值 QPS)、给谁用(容量规划)、错了怎么办(冗余与预案)。

详细步骤

  1. 能拿历史数据,就别估。 同类型活动(同品类、同价格带、同时间段)的历史峰值是最好的输入。做同比环比,并按品类调整系数。

  2. 没有历史数据时,用”参与人数 × 行为系数”建模:

峰值 QPS = 参与人数 × 刷新系数 × 点击集中度 ÷ 尖峰窗口秒数
参与人数 = 预约人数 × 到场率

这三个系数都来自上一节的行为规律,取值范围相对稳定(到场率 70%-95%、刷新系数 5-10、集中度 0.6-0.9)。

  1. 用商品热度和宣传力度修正参与人数。搜索指数、社交话题阅读量、预热物料的曝光量都能作为参与人数的佐证;多个品类同时开抢要额外考虑叠加效应。

  2. 规划时按最激进的一档准备资源,再乘冗余系数(1.5 左右)。压测得到的是健康状态下的极限,活动当天总有 GC、坏节点、慢网络。

  3. 预测必须转化为压测输入。 拿预测出的峰值 QPS 和流量模型(请求分布、参数分布、刷新行为)去压测,压测脚本要模拟真实用户的刷新节奏,而不是单纯用固定速率的循环请求。

  4. 留出可动态调整的余量,比如容器化的实例数可以按活动配置临时扩缩,而不是活动前就固定。

  5. 准备预案,而不是只准备资源。 预测偏高会浪费成本,预测偏低会崩系统——两种情况的应对策略不同:前者可以临时收缩,后者必须能快速扩容或降级。

  6. 活动当天用实时指标校正。 预测是活动前的输入,活动中的实际 QPS、到达速率和积压趋势才是决策依据。超过激进档就执行降级预案。

最终答案

优先级是:历史数据 > 预约人数模型 > 热度佐证。模型用”参与人数 × 刷新系数 × 点击集中度 ÷ 窗口秒数”,规划按最激进一档乘冗余系数,然后用这个峰值作为压测输入。最后一定要配预案——预测用来定容量,预案用来兜住预测的偏差。

问题 3:为什么说”静态资源”是最大的流量来源?

提示:

  • 图片、JS、CSS占比70%
  • 可以通过CDN解决
  • 不需要打到源站
CDN静态资源流量削减

解题思路

关键在于分清请求数和请求成本。一个秒杀页面的请求里,真正的业务接口可能只有一个,但为了渲染它要拉十几次静态资源。把请求数从源站挪走,比优化业务接口省下的更多。

详细步骤

  1. 算一笔账:一个活动页大致需要 1 个 HTML、1 个 CSS、3-5 个 JS、10-20 张图片,加上 1-2 个业务接口。静态资源占了请求总数的 90% 以上。

  2. 再叠加刷新:紧张的用户在开抢前刷新 30 次,每次都重新请求这些资源。50 万人 × 30 次刷新 × 15 个资源 = 2.25 亿次静态资源请求。这个数字比业务接口高出几个数量级。

  3. 静态资源有三个特性,注定它应该由 CDN 承担:

    • 内容不变:同一张图,所有人看到的一模一样
    • 可缓存:带强缓存头,边缘节点可以直接返回
    • 可容忍延迟:一张图晚加载 100ms,用户完全无感
  4. CDN 接入后的效果:这些请求在最近的边缘节点就返回了,不消耗源站的带宽、不消耗源站的 CPU、不经过源站的限流和排队。源站只需要处理业务接口那 5%-10% 的流量。

  5. 它对秒杀主链路的意义:静态资源不再占用 Nginx 的连接数和带宽,源站的资源全部留给业务接口。在网络带宽成为瓶颈时,这一条能直接决定业务接口的 QPS 上限——前面监控大盘里”网络带宽 85%“的那个指标,靠 CDN 就能压下来。

  6. 要注意的三个坑:

    • 活动开始时必须刷新预热,否则用户拿到的是旧版本页面(活动时间不对、规则不对)
    • 缓存策略要分层:HTML 短缓存或不缓存(活动时间敏感),图片和 JS 长缓存
    • 源站要能承受 CDN 回源——缓存未命中时流量会回源,CDN 挂了流量会全量回源
  7. 不能把所有流量都交给 CDN:业务接口(库存、排队、下单)是动态的、必须实时计算,CDN 帮不上忙。这部分要靠限流、排队和 Redis 来扛。

最终答案

因为一个活动页的请求里九成以上是图片、JS、CSS 这些内容不变、可缓存、可容忍延迟的静态资源,再加上开抢前的高频刷新,总量比业务接口高出一到两个数量级。CDN 让这些请求在边缘节点返回,完全不经过源站,释放出的带宽和连接数全部留给真正的业务接口——这往往是单条性价比最高的削峰手段。注意 HTML 的活动开始预热、分层缓存策略,以及源站要扛得住回源。

发现内容有问题?

告诉我们哪里需要改进。