那些大站是如何扛住几百万甚至几亿人访问的

一句话读懂:一台 4 核 8G 的机器扛不住 30 万人同时在线,不是 CPU 不行,而是临时端口、文件句柄、accept 队列和线程池先撞到了天花板。本文用一笔容量账把负载均衡、缓存、读写分离、分片、CDN、消息队列七层手段逐层拆开,讲清每一层解决什么问题、代价是什么、什么时候才值得上。

🧮 01 先算一笔账:30 万在线到底有多大

标题里的“几百万甚至几亿人访问”,说的是注册用户或日活;对容量设计真正有意义的,是同一时刻的在线人数——一个日活上亿的应用,同一秒在线往往也就是百万级。下面按一个不算激进的假设来算这笔账:30 万人同时在线,平均每人每分钟产生 2 个请求(刷新一次列表、点开一次详情),总请求量就是 60 万次/分钟,也就是 1 万 QPS。

“30 万人在线”也最容易被误读成“30 万个连接”。连接本身并不贵:今天一台 4 核 8G 的机器,用 epoll 维持十万个空闲长连接并不困难。真正贵的是这些连接在同一秒里要发起多少请求。一个“查一次缓存、拼一次 JSON、偶尔查一次库”的接口,压测下来单实例大概能稳定跑住 800 QPS,再往上 P99 就开始抖。1 万除以 800,是 13 台;考虑到冗余和发布时的滚动下线,实际要准备 15 台左右。

一台机器扛不住,原因也不只是 CPU。它同时有四个互相独立的天花板:

  • 临时端口:机器作为客户端去连数据库、Redis、下游服务时,本机可用的源端口只有 32768–60999 这一段,约 2.8 万个,短连接一多就会被耗尽,报 Cannot assign requested address
  • 文件句柄:每个 socket 占一个 fd,很多发行版的 ulimit -n 默认只有 1024,连接数一上来就先撞到这里
  • accept 队列:内核的 somaxconn 和应用的 backlog 决定“已握手但还没被取走”的连接能排多长,队列一满,新的 SYN 直接被丢,客户端只能超时重试,反而把压力放大
  • 工作线程:200 个工作线程如果都阻塞在数据库上,线程池打满之后,请求在应用内部就开始排队

先把这几个值查一遍,比盲目加机器有用:

# 本机可用的临时端口范围
sysctl net.ipv4.ip_local_port_range

# 已完成三次握手、等待 accept 的队列上限
sysctl net.core.somaxconn

# 单进程能打开的文件句柄数
ulimit -n

按上面的模型,容量大概是这样一笔账:

指标 假设 推算结果
在线用户 30 万 —
人均请求 2 次 / 分钟 约 1 万 QPS
单实例能力 800 QPS 至少 13 台,留冗余按 15 台
单表数据量 1.3 亿行 索引约 40 GB,超过单机内存
读写比 9 : 1 读 9000 QPS,写 1000 QPS

这张表基本决定了后面每一层要不要上:读多写少,缓存和从库就有意义;单表超过内存,就要考虑分片;带宽被图片视频吃掉,就该让 CDN 接管。

一台服务器:先算清楚天花板

⚖️ 02 负载均衡:先把应用做成无状态

有了十几台机器,就需要一个入口把请求分下去。但在挂负载均衡之前,有个更重要的前提:这些机器必须彼此等价。否则流量分过去了,请求也处理不了。

无状态有两条硬约束:

  • 会话不放本地内存:登录态放进 Redis,或者直接签名进 token;本地缓存只放可重建的数据(配置、字典、权限列表),不能放“这个用户刚才点了什么”
  • 上传文件不落本地盘:写进本机磁盘的文件,下一台机器读不到。要么用对象存储,要么用共享存储,总之不能依赖某台机器的本地目录

粘性会话(sticky session)是常见的过渡方案:按 cookie 把同一个用户固定到同一台机器。它能让老代码不改就上线,代价是负载不均、机器下线时会话全丢、扩容时新机器分不到老用户。可以短期用,不适合长期依赖。

真正让“随时摘掉一台”变得安全的是健康检查:

  • 每 2 秒请求一次 GET /health,接口返回 200 且依赖可用才算健康
  • 连续 3 次失败就摘掉,恢复后自动加回,不靠人改配置
  • 摘除时先停止新请求,等在途请求处理完再断开连接,也就是优雅下线;否则每次发布都会丢一批 502

按工作层次,负载均衡一般分两种:四层(LVS、F5)只看 IP 和端口,转发快、功能少;七层(Nginx、云上的 ALB)能看 URL 和 Header,可以按路径分流、做灰度发布、改写请求头,代价是多一次解析和一点延迟。大多数业务从七层开始就够了。

负载均衡:把流量摊开

⚡ 03 缓存:把读请求挡在数据库前面

读写比 9 : 1,意味着 1 万 QPS 里有 9000 次是读。让这 9000 次都去查库,是最不划算的做法:数据库的连接数、缓冲池、磁盘 IO 都是有限的,而热点数据通常只占总量的一小部分。

最常用的模式叫 cache-aside,流程只有三步:

  1. 先读缓存,命中就直接返回
  2. 没命中,查数据库
  3. 把结果写回缓存,并设置过期时间

按 98% 的命中率算,1 万 QPS 里只有 200 次真正落到数据库。命中时延在 0.3 ms 量级,未命中才是一次库查询的几毫秒。

缓存用起来不难,难的是它失效的那一刻。三个经典故障,几乎每个团队都踩过:

  • 穿透:一直查一个不存在的 id,缓存永远不命中,请求全部打到库上。解法是缓存空值,或者用布隆过滤器在入口先挡掉
  • 击穿:某个热点 key 刚过期,几千个请求同时回源。解法是互斥重建(只放一个请求去查库),或者逻辑过期(后台异步刷新,前台继续返回旧值)
  • 雪崩:大批 key 在同一时刻过期,或者缓存集群整体挂掉。解法是给 TTL 加随机抖动、做多级缓存,以及在缓存层加限流兜底

还有一个绕不开的问题是一致性。通行的做法是先更新数据库,再删除缓存,而不是更新缓存;即使这样,也存在极小概率的不一致窗口。对昵称、头像、列表这类数据,几秒的延迟通常可以接受;对余额、库存这类必须准确的读,就不要走缓存,或者用版本号、分布式锁做额外保证。

缓存:让读请求不落到数据库

📚 04 读写分离:写一份,读很多份

即使有缓存,剩下 10% 的读和全部写仍然落在数据库上。单台数据库的连接数和写入能力有限,最直接的拆法是:写只进主库,读分给从库。

从库的数据来自主库的 binlog:主库把每一次变更写进 binlog,从库的 IO 线程把它拉过来,SQL 线程再重放一遍。为了让“提交成功”更可靠,很多团队会开半同步复制——至少有一个从库确认收到 binlog 才返回提交成功,代价是每次写入多等一个网络往返。

复制带来的直接问题是延迟。同机房通常在几十毫秒,跨机房可能到几百毫秒。于是就有了“读己之写”问题:用户刚改完昵称,刷新页面看到的是旧名字。

常见的处理方式有三种:

  • 写完之后的短时间窗口内(比如 1 秒),这个用户的读请求走主库
  • 把“我刚写过”的标记放进 session 或 Redis,读请求带上这个标记
  • 对一致性要求高的接口,直接指定读主库

主库本身仍然是单点。真正让它高可用的是主从切换:哨兵、MHA,或者云厂商托管的自动切换。切换过程中最难的部分不是切过去,而是处理脑裂和数据回滚——这套机制的成本,往往比读写分离本身还高。

读写分离:写一份,读多份

🗂️ 05 分片:一张表真的扛不住的时候

加索引、加内存、加从库,都能延缓“单表太大”的问题,但延缓不等于解决。当一张表有 1.3 亿行、索引 40 GB,而单机内存只有 32 GB 时,索引装不进内存,每次查询都可能是一次随机磁盘 IO。这时候才轮到分片。

分片的核心是选一个分片键,它决定了数据怎么摊开,也决定了以后扩容有多痛:

  • 按 user_id 取模:数据分布均匀,单条查询能直接定位;但从 3 个库扩到 4 个库时,几乎要搬动全部数据
  • 按范围(时间、ID 段):扩容容易,新分片接着往后放;但新写入会集中在一个分片上,形成热点
  • 一致性哈希:扩容只影响相邻的一段数据,代价是实现更复杂,还要调虚拟节点来保证均衡

查询也要跟着改。带分片键的查询能落到单个分片;不带分片键的查询要广播到所有分片再聚合,分片越多越慢。分页、排序、join 都要在应用层重新实现:

-- 带分片键:只落一个分片
SELECT * FROM t_order WHERE user_id = 1024 AND created_at > '2026-11-01';

-- 分片路由由应用按取模计算,而不是数据库替你完成
-- shard = user_id % 3

扩容一般走“双写 → 迁移 → 校验 → 切读 → 下线旧库”这套流程,按周甚至按月计算。此外,自增 ID 在主从和分片下不再可靠,通常会换成雪花算法这类“时间戳 + 机器号 + 序列”的全局 ID。

所以分片是最后一张牌:它能解决单表容量,但会把跨片查询、扩容搬迁、全局 ID 三个问题一起带进来。

分片:一张表切成好几张

🌐 06 CDN:静态资源不该挤业务链路

一次页面加载,80% 以上的字节是图片、JS、CSS、字体和视频。这些内容跟“用户是谁”无关,完全可以缓存到离用户几十公里的边缘节点上——这就是 CDN 做的事。

CDN 的收益全在“命中”两个字上:

  • 命中:边缘节点直接把文件返回,通常 20 ms 级,不用回源
  • 未命中:边缘回源到对象存储或源站取一次,取回后存在本地,下次就近返回
  • 刷新与预热:发布新版本时要主动刷新 URL,大促前把热点资源预热到边缘,否则第一批用户会把回源打满

按 98% 的边缘命中率算,只有 2% 的请求会回到源站,源站带宽和连接数都省下来了。

需要注意的是,CDN 只适合“内容不变或变化很少”的资源。API 响应默认不该缓存;确实需要时,要按 URL + 参数设置很短的 TTL,并接受短暂的不一致。图片改版后如果没刷新缓存,用户可能几天都看到旧图,这类问题在发布流程里要提前设计好。

CDN:把静态资源推到离用户最近的地方

📮 07 消息队列:把尖峰削成平峰

活动开始的第一分钟,请求量可能是平时的五倍。数据库的连接数和写入能力是固定的,多出来的请求只有两个去处:拒绝,或者排队。

队列做的就是“排队”:

  • 应用把“要做什么”写成消息投进队列,立刻返回“已受理”
  • 消费者按自己的速度取,数据库按自己的节奏写
  • 峰值被摊到一个更长的时间窗口里,尖峰变成了平峰

以一次下单活动为例,一分钟涌入 5 万次请求,折算约 833 QPS,而订单库稳定只能吃 300 QPS 左右:

指标 直接打库 经消息队列
峰值压力 833 QPS 瞬时打到订单库 队列先接住,库侧维持 300 QPS
用户侧体验 大量超时、下单失败 立即返回“已受理”
积压消化 无缓冲,直接丢请求 约 3 分钟内消化完(5 万 ÷ 300 ≈ 167 秒)
数据一致性 强一致 最终一致,秒级延迟

代价同样明确:

  • 最终一致:用户看到“已受理”,实际入库可能延迟几秒,页面要能表达“处理中”
  • 幂等:消息通常是“至少一次”投递,消费端必须用唯一键或去重表挡住重复消费
  • 顺序:同一订单的多条消息需要有序时,要用同一个分区键,并接受分区内的串行
  • 可观测:积压量、消费延迟、死信队列都要有监控,否则队列只会把故障藏起来

消息队列:把浪头削平

🧩 08 把七层拼回去:代价与取舍

把这七层串起来看,顺序其实很清楚:先估算容量,再把应用做成无状态、挂上负载均衡;读压力大了加缓存;写压力大了做读写分离;单表真的到极限才分片;静态资源交给 CDN;瞬时尖峰交给消息队列。

每一层都不是免费的:

  • 负载均衡:会话要外置,发布要优雅下线
  • 缓存:要处理穿透、击穿、雪崩,还要接受短暂的不一致
  • 读写分离:要面对复制延迟和主从切换
  • 分片:要面对跨片查询、扩容搬迁和全局 ID
  • CDN:要做刷新和预热,要接受“用户可能看到旧文件”
  • 消息队列:要接受最终一致,要做幂等和积压监控

这七层之外,还有一套不增加容量、只在容量被击穿时保命的手段:限流、降级、熔断。它们的原则是宁可拒绝一部分请求,也不能让整站被拖死——真到几亿访问的量级,这套自保机制和上面七层同等重要。

所以判断标准不是“大站都这么做”,而是“我现在的瓶颈在哪一层”。能用一台机器加一个索引解决的问题,不要上分片;能在数据库里加个索引解决的慢查询,不要先上缓存。每加一层,都是在用复杂度换容量——容量可以买,复杂度只能自己扛。

把七层拼回去

posted @ 2026-11-18 20:37  源动力技术栈  阅读(3)  评论(0)    收藏  举报