# 缓存|计算机基础篇

> 本文系统介绍了缓存的基本概念、命中率、最大空间、常见淘汰策略（FIFO、LRU、LFU），以及缓存在浏览器、ISP、反向代理、本地、分布式和数据库等不同位置的应用场景，帮助读者全面理解缓存的原理与实践。

- 原文：https://feinterview.poetries.top/docs/fe-base-docs/compute-docs/%E7%BC%93%E5%AD%98
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.08
- 可见范围：免费部分

---

## 一、缓存特征

- 缓存的本质：拿空间换时间，把算过的、查过的结果存起来下次直接用
- 两个核心指标：命中率（多少请求被缓存接住）、最大空间（能存多少）
- 空间满了要淘汰：`FIFO` 看谁先进来，`LRU` 看谁最久没被用，`LFU` 看谁用得最少
- 选策略看业务怎么定义「热」：只要新数据用 `FIFO`，近期热点用 `LRU`，长期高频用 `LFU`
- 默认首选 `LRU`，实现简单（`Map` 就能写），大多数访问都有时间局部性

**缓存就是用空间换时间，看它好不好用主要看两件事：命中率高不高，空间满了删谁。** 命中率是请求被缓存直接接住的比例，越高说明缓存越值。缓存一般放在内存里，空间有限，满了就得淘汰：`FIFO` 先进先出，`LRU` 删最久没访问的，`LFU` 删访问次数最少的。我一般默认用 `LRU`，因为大部分业务都是最近用过的东西接下来还会用，比如浏览器的内存缓存、`Vue` 的 `keep-alive` 加了 `max` 之后也是 `LRU`。

缓存讨论的所有问题，几乎都能落到两个特征上：命中率和最大空间。

命中率决定缓存值不值。假设一次数据库查询要 `50ms`，缓存读取要 `1ms`，命中率 `90%` 时平均耗时大约是 `0.9 × 1 + 0.1 × 51 ≈ 6ms`；命中率掉到 `50%`，平均耗时就变成 `26ms`，数据库压力也翻了几倍。所以缓存上线之后，命中率是第一个要盯的指标。

最大空间决定能放多少。缓存一般在内存里，容量远小于磁盘，满了就必须淘汰。三种经典淘汰策略的区别可以用一个例子记住：容量 `3`，访问序列 `A B C A A B D`。

- `FIFO` 只看进入顺序，`D` 进来时淘汰最早进来的 `A`，哪怕 `A` 刚被访问过两次
- `LRU` 只看最近一次访问时间，`A` 和 `B` 刚用过，淘汰 `C`
- `LFU` 只看访问次数，`A` 三次、`B` 两次、`C` 一次，也淘汰 `C`

前端里最常见的是 `LRU`：浏览器内存缓存、`Vue` 的 `keep-alive` 配了 `max`、各种请求库的结果缓存都在用。用 `JS` 写一个 `LRU` 非常短，因为 `Map` 本身记住了插入顺序：

```js
class LRU {
  constructor(max) { this.max = max; this.map = new Map(); }
  get(k) {
    if (!this.map.has(k)) return undefined;
    const v = this.map.get(k);
    this.map.delete(k); this.map.set(k, v); // 挪到最新
    return v;
  }
  set(k, v) {
    this.map.delete(k);
    this.map.set(k, v);
    if (this.map.size > this.max) this.map.delete(this.map.keys().next().value); // 删最旧
  }
}
```

- **容量 `3`，依次写 `A`、`B`、`C`，读一次 `A` 再写 `D`，`LRU` 淘汰谁？**

  淘汰 `B`。读 `A` 之后 `A` 变成最近使用的，最久没被碰过的是 `B`。如果写出来淘汰的是 `A`，说明 `get` 没刷新顺序，实际变成了 `FIFO`。

- **资讯流只关心最新内容，有人提议用 `LFU` 保留热门旧文，合适吗？**

  不合适。`LFU` 会让几天前的爆款一直霸着位置，跟「只看新内容」的目标是反的。这种场景 `FIFO` 或者干脆按时间 `TTL` 过期更贴切。

- **用 `LRU` 做缓存，后台每天跑一次全量导出，第二天命中率掉得很厉害，为什么？**

  全量扫描把一大堆只用一次的数据塞进来，按 `LRU` 规则它们都是「最近用过的」，真正的热点反而被挤出去了，这叫缓存污染。可以让扫描任务绕过缓存，或者换成 `LRU-K`、`2Q` 这类要访问两次才算热的策略。

- **`LFU` 跑了半年，新上的活动商品老是进不了缓存，怎么回事？**

  计数只增不减，半年前的老热点攒了几十万次，新商品永远比不过。要加时间衰减，比如每隔一段时间把所有计数减半，`Redis` 的 `LFU` 实现里就带了衰减。

## 命中率

- 命中 = 请求被缓存直接接住，不用再去查数据库或回源
- 命中率 = 命中次数 / 总请求数，比如 `1000` 次里 `800` 次命中就是 `80%`
- 分母口径要先对齐：`bypass`、过期后 `304` 校验、报错请求算不算，不同团队的 `90%` 没法直接比
- 别只看整体比例：按接口、按 `key` 前缀拆开看，再配合回源量、`miss`、`expired`、`evicted` 一起看
- 命中率高不等于快：缓存本身慢、或者 `TTL` 拉太长返回旧数据，都是代价

**命中率就是请求里有多少比例被缓存直接接住了，它决定了缓存到底帮你挡掉了多少流量。** 算法很简单，命中次数除以总请求数，难的是口径：主动绕过缓存的、过期后去源站校验的算不算，要先说清楚。整体数字还很容易骗人，某个大接口命中率高，就能把一个命中率只有 `20%` 的小接口藏起来。所以我看监控一般会拆到接口和 `key` 前缀，同时看回源量，回源量才是数据库真正承受的压力。

当某个请求能够通过访问缓存而得到响应时，称为缓存命中。

缓存命中率越高，缓存的利用率也就越高。

**原理拆解：** 请求到达缓存层后，系统先依据缓存键查找条目，再检查条目是否存在、是否过期以及是否满足当前请求的复用条件。只有缓存能够直接提供有效结果，且无需继续访问源站、数据库或计算服务时，才算命中；未找到、已过期、主动绕过缓存或必须回源校验后才能取得结果，通常计为未命中。常见统计口径是 `命中次数 / 可统计请求总数`，但分母是否包含绕过请求、错误请求和刷新请求必须由具体系统定义，不能脱离监控口径直接比较。

**具体例子：** 某接口在一个统计周期内收到 `1000` 次可统计请求，其中 `800` 次由缓存直接返回，按上述口径命中率为 `80%`。若热点数据集中在少数缓存键上，即使缓存条目数量不多，也可能获得较高命中率；反过来，大量低频且互不重复的请求即使都写入缓存，后续没有复用，命中率仍然较低。提升命中率通常能减少回源次数，但并不自动等于响应更快或成本更低，还要考虑缓存访问耗时、序列化开销和失效维护成本。

**边界与排查：** 命中率必须结合统计周期、请求维度和缓存层级理解。整体命中率可能掩盖某个接口、租户或缓存键前缀的低命中；多级缓存中，本地缓存未命中而分布式缓存命中，也要明确是分别统计还是合并统计。过长的过期时间可以抬高命中率，却可能返回陈旧数据；缓存穿透、键设计不稳定、容量淘汰和集中失效则会使命中率下降。

**工程验证：** 监控时应同时采集 `hit`、`miss`、`bypass`、`expired`、`evicted` 和回源量，并按接口与缓存键类别分组。将命中率曲线与缓存延迟、源站负载、错误率及数据新鲜度对照：若命中率升高但延迟未下降，应检查缓存本身是否变慢；若命中率突然下降且回源量同步上升，应排查批量过期、发布后键格式变化、缓存容量不足或节点故障。

- **发版后几分钟命中率从 `92%` 掉到 `60%`，请求量没变，先查什么？**

  先怀疑缓存 `key` 变了，比如新版本给 `key` 加了个版本号或改了拼接字段，旧缓存全部作废。再看 `expired` 和 `evicted` 哪个涨了：前者是批量过期，后者是容量不够。

- **命中率从 `92%` 降到 `70%`，数据库压力一定翻倍吗？**

  不一定。如果是多级缓存，本地缓存没中可能还会被 `Redis` 接住，真正打到数据库的是回源量。直接看数据库 `QPS` 和回源量才能下结论。

- **业务想把 `TTL` 从 `1` 分钟改成 `1` 小时来提命中率，你怎么看？**

  命中率确实会涨，但内容改了之后最多 `1` 小时用户才看到。价格、库存这种不能这么干；文章、配置这种可以，最好配合写后主动删缓存，既拉长 `TTL` 又不怕旧。

- **前端怎么看一个静态资源到底有没有命中浏览器缓存？**

  看 `Network` 面板的 `Size` 列：`(memory cache)` 或 `(disk cache)` 是强缓存命中，没发请求；状态码 `304` 是协商缓存，发了请求但没下载内容。只看耗时变短不能证明命中。

## 最大空间

- 缓存放内存，内存比磁盘小得多，所以必须设上限，不能无限往里塞
- 上限可以按条目数，也可以按字节数；单条大小差异大时只限条目数等于没限
- 满了就淘汰旧数据再写新数据，淘汰谁由策略决定（`LRU` / `LFU` / `FIFO`）
- 上限别设成机器全部内存，要给业务对象、`GC`、突发流量留余量
- 扩容只能推迟淘汰，命中率上不去时先看访问有没有局部性、`key` 有没有被随机参数打散

**缓存必须有最大空间，因为它占的是内存，不设上限迟早把进程撑爆。** 前端最常见的反例就是拿一个全局 `Map` 当缓存，只 `set` 不删，翻页、搜索一多，内存一路上涨。设了上限之后，写入超出时就按淘汰策略删掉一部分。还有一点容易忽略：限 `1000` 条不等于内存可控，一条 `1KB` 和一条 `5MB` 差别巨大，值大小不均的时候我会按估算字节数来限。

缓存通常位于内存中，内存的空间通常比磁盘空间小的多，因此缓存的最大空间不可能非常大。

当缓存存放的数据量超过最大空间时，就需要淘汰部分数据来存放新到达的数据。

**原理拆解：** 缓存空间上限本质上是一项资源预算，可以按条目数、估算字节数或运行时提供的内存指标控制。写入链路通常是：检查键是否已存在，计算写入后的占用量，若超过上限则执行淘汰，释放足够空间后再接纳新值。上限并不等于进程可用内存总量，还要为业务对象、运行时堆、网络缓冲区和突发流量保留余量，否则缓存尚未达到配置值，进程就可能因内存压力频繁回收甚至退出。

**最小验证：** 输入依次为 `a`、`b`、再次读取 `a`、写入 `c`，验证容量为 `2` 的 `LRU` 缓存会淘汰最久未使用的 `b`，而不是简单删除最早创建的 `a`。

```js
class LRUCache {
  constructor(maxEntries) {
    if (!Number.isInteger(maxEntries) || maxEntries < 1) {
      throw new RangeError('maxEntries must be a positive integer');
    }
    this.maxEntries = maxEntries;
    this.store = new Map();
  }

  get(key) {
    if (!this.store.has(key)) return undefined;
    const value = this.store.get(key);
    this.store.delete(key);
    this.store.set(key, value);
    return value;
  }

  set(key, value) {
    if (this.store.has(key)) this.store.delete(key);
    this.store.set(key, value);
    while (this.store.size > this.maxEntries) {
      const oldestKey = this.store.keys().next().value;
      this.store.delete(oldestKey);
    }
  }

  keys() {
    return [...this.store.keys()];
  }
}

const cache = new LRUCache(2);
cache.set('a', 1);
cache.set('b', 2);
cache.get('a');
cache.set('c', 3);
console.log(cache.keys());
console.log(cache.get('b'));
```

`get` 通过删除后重新插入更新访问顺序；超限循环删除 `Map` 中最早的键。预期输出为 `[ 'a', 'c' ]` 和 `undefined`。该实现限制的是条目数：若单个值大小差异很大，它不能代表真实内存占用，也没有处理过期时间和并发一致性。

**边界与排查：** 容量调大只会降低淘汰频率，并不会消除边界；容量过小则可能形成持续写入、立即淘汰的缓存抖动。工程验证应同时观察命中率、淘汰次数、写入失败、进程堆占用和延迟分位数，并用接近生产的数据尺寸做压测。若命中率随容量增加仍无明显改善，应排查访问是否缺乏局部性、键是否被随机参数打散，或数据是否在再次访问前已经过期，而不是继续盲目扩容。

- **组件里用全局 `Map` 缓存每个搜索词的结果，用久了页面越来越卡，怎么改？**

  加上限和淘汰，最简单是写个 `LRU`：`if (map.size > 100) map.delete(map.keys().next().value)`。不在乎跨页面保留的话，干脆把缓存挂到组件实例上，卸载时一起释放。

- **缓存限制了 `10000` 条，同事说内存已经可控了，你同意吗？**

  要看值的大小。如果有的条目是几十字节的配置，有的是几 `MB` 的列表，`10000` 条可能是几 `MB` 也可能是几十 `GB`。值大小不均时按字节数限，比如 `lru-cache` 就支持 `maxSize` 加 `sizeCalculation`。

- **缓存容量翻倍了，命中率几乎没涨，还要继续加吗？**

  先别加。命中率不随容量涨，说明问题不在空间：可能 `key` 里带了时间戳、随机数，每次都是新 `key`；也可能 `TTL` 太短，还没被第二次访问就过期了。

- **能不能直接把缓存上限设成进程可用内存的上限，最大化命中率？**

  不行。进程还要放业务对象、请求缓冲区，`Node` 进程堆快满时 `GC` 会越来越频繁，延迟先抖起来，严重了直接 `OOM` 退出。一般给缓存划一块明确预算，留出余量。

## 淘汰策略

- 淘汰策略回答一个问题：缓存满了，先删谁
- `FIFO`：谁先进来删谁，读取不改变位置，实现最简单，但不识别热点
- `LRU`：删最久没被访问的，每次命中都要挪到最新；怕一次性大批扫描把热点挤掉
- `LFU`：删访问次数最少的；怕老热点计数太高赖着不走，要加衰减
- 高性能 `LRU` = 哈希表 + 双向链表，`get` / `put` 都是 `O(1)`；`JS` 里一个 `Map` 就够

**三种淘汰策略的区别就在于「凭什么判断一条数据没用了」：`FIFO` 看进来的先后，`LRU` 看最后一次用是什么时候，`LFU` 看一共用了几次。** 举个例子，容量 `3`，访问 `A B C A A B D`：`FIFO` 会删 `A`，因为它最早进来，哪怕刚被读了两次；`LRU` 和 `LFU` 都删 `C`。实际项目里 `LRU` 用得最多，`Redis` 的 `allkeys-lru`、`Vue` 的 `keep-alive` 都是它；`LFU` 适合热点长期稳定的场景，但一定要有计数衰减。

- FIFO（First In First Out）：先进先出策略，在实时性的场景下，需要经常访问最新的数据，那么就可以使用 FIFO，使得最先进入的数据（最晚的数据）被淘汰。

- LRU（Least Recently Used）：最近最久未使用策略，优先淘汰最久未使用的数据，也就是上次被访问时间距离现在最久的数据。该策略可以保证内存中的数据都是热点数据，也就是经常被访问的数据，从而保证缓存命中率。

- LFU（Least Frequently Used）：最不经常使用策略，优先淘汰一段时间内使用次数最少的数据。

## 二、缓存位置

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-base-docs/compute-docs/%E7%BC%93%E5%AD%98
