知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 10 - 分布式缓存与数据库 ## 分布式缓存 ### Redis Cluster 架构  *图:Redis Cluster 的 16384 槽位与主从副本* ``` ┌─────────────────────────────────────────────────────────────┐ │ Redis Cluster │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 16384 个槽位(Slot)分布在多个节点 │ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Node A │ │ Node B │ │ Node C │ │ │ │ Slot 0-5460 │ │Slot 5461-10922│ │Slot 10923-16383│ │ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │ │ │ │ │ │ │ ▼ ▼ ▼ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Replica A │ │ Replica B │ │ Replica C │ │ │ │ (从节点) │ │ (从节点) │ │ (从节点) │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ 槽位计算:slot = CRC16(key) % 16384 │ │ │ └─────────────────────────────────────────────────────────────┘ ```  ### 缓存模式  *图:Cache-Aside、读写穿透与异步写回的区别* ``` 1. Cache-Aside(旁路缓存) ┌────────────────────────────────────────────────────────────┐ │ │ │ 读取: │ │ ┌────────┐ 1.查缓存 ┌─────────┐ │ │ │ Client │ ───────────→ │ Cache │ │ │ │ │ ←────────────│ (Miss) │ │ │ │ │ └─────────┘ │ │ │ │ 2.查数据库 ┌─────────┐ │ │ │ │ ───────────→ │ DB │ │ │ │ │ ←────────────│ │ │ │ │ │ 3.写缓存 ┌─────────┐ │ │ │ │ ───────────→ │ Cache │ │ │ └────────┘ └─────────┘ │ │ │ │ 写入: │ │ 1. 更新数据库 │ │ 2. 删除缓存(而不是更新缓存) │ │ │ └────────────────────────────────────────────────────────────┘ 2. Read/Write Through(读写穿透) ┌────────────────────────────────────────────────────────────┐ │ │ │ 应用只与缓存交互,缓存负责与数据库同步 │ │ │ │ ┌────────┐ ┌─────────┐ ┌─────────┐ │ │ │ Client │ ←─────→ │ Cache │ ←─────→ │ DB │ │ │ └────────┘ └─────────┘ └─────────┘ │ │ │ │ │ 缓存层封装 │ │ DB 操作 │ │ │ └────────────────────────────────────────────────────────────┘ 3. Write Behind(异步写回) ┌────────────────────────────────────────────────────────────┐ │ │ │ 写入缓存后立即返回,异步批量写入数据库 │ │ │ │ ┌────────┐ 写入 ┌─────────┐ 异步批量 ┌─────────┐ │ │ │ Client │ ──────→ │ Cache │ ─────────→ │ DB │ │ │ └────────┘ 立即返回└─────────┘ └─────────┘ │ │ │ │ 优点:写入性能高 │ │ 缺点:可能丢数据 │ │ │ └────────────────────────────────────────────────────────────┘ ```  ```java // Cache-Aside 实现 @Service public class CacheAsideService { @Autowired private RedisTemplate<String, Object> cache; @Autowired private UserRepository db; // 读取 public User getUser(String userId) { String key = "user:" + userId; // 1. 查缓存 User user = (User) cache.opsForValue().get(key); if (user != null) { return user; } // 2. 缓存未命中,查数据库 user = db.findById(userId).orElse(null); if (user != null) { // 3. 写入缓存 cache.opsForValue().set(key, user, 30, TimeUnit.MINUTES); } return user; } // 写入 @Transactional public void updateUser(User user) { String key = "user:" + user.getId(); // 1. 更新数据库 db.save(user); // 2. 删除缓存(而不是更新) cache.delete(key); } } ``` ### 缓存一致性问题  *图:并发双写不一致与 Canal 订阅 binlog 扇出* ``` 问题场景:并发更新时的不一致 时间线 ─────────────────────────────────────────→ 线程 A(写操作): 更新 DB ────────────────────────── 删除缓存 │ 线程 B(读操作): │ 查缓存(Miss) ─┼─ 查 DB ─── 写缓存(旧值) │ 此时 B 读到的是更新前的旧值 解决方案: 1. 延迟双删 - 删除缓存 - 更新数据库 - 延迟一段时间 - 再次删除缓存 2. 订阅 Binlog - 通过 Canal 等工具监听数据库变更 - 异步更新/删除缓存 Canal Binlog 订阅架构: ┌─────────────────────────────────────────────────────────────────┐ │ Canal 数据同步架构 │ │ │ │ ┌─────────┐ 写入 ┌──────────┐ binlog ┌──────────┐ │ │ │ 业务应用 │────────→│ MySQL │───────────→│ Canal │ │ │ │ │ │ (主库) │ │ Server │ │ │ └─────────┘ └──────────┘ └────┬─────┘ │ │ │ │ │ ┌──────────┼───────┐ │ │ ▼ ▼ ▼ │ │ ┌──────┐ ┌──────┐ ┌──────┐│ │ │Cache │ │Search│ │Data ││ │ │Update│ │Index │ │Ware- ││ │ │(Redis│ │(ES) │ │house ││ │ │删缓存│ │更新 │ │同步 ││ │ └──────┘ └──────┘ └──────┘│ └─────────────────────────────────────────────────────────────────┘ 流程: 1. 业务应用写入 MySQL 主库 2. MySQL 生成 binlog 3. Canal 伪装成 MySQL 从库,获取 binlog 事件 4. Canal 解析 binlog,提取表变更事件(INSERT/UPDATE/DELETE) 5. 推送事件到下游消费者(MQ、RPC) 6. 下游消费者更新 Redis / ES / 大数据平台等 为什么不用"删缓存 + 查数据库 + 写缓存"的方式? 可能导致短暂不一致窗口 Canal 是基于 binlog(数据库真实变更),更可靠 Canal 核心优势: ├── 对业务无侵入:不需要改业务代码 ├── 实时性:毫秒级同步延迟 ├── 可靠性:基于 binlog(已持久化),宕机不丢数据 └── 解耦:一个 binlog → 多个消费者(按需订阅)  3. 分布式锁 - 写操作加锁 - 读操作判断锁状态 ```  ```java // 延迟双删 @Service public class DelayDoubleDeleteService { @Autowired private RedisTemplate<String, Object> cache; @Autowired private ThreadPoolTaskScheduler scheduler; @Transactional public void updateUser(User user) { String key = "user:" + user.getId(); // 1. 删除缓存 cache.delete(key); // 2. 更新数据库 userRepository.save(user); // 3. 延迟删除(异步) scheduler.schedule(() -> { cache.delete(key); }, Instant.now().plusMillis(500)); } } // 基于 Canal 的缓存更新 @Component public class CanalCacheSync { @Autowired private RedisTemplate<String, Object> cache; @CanalEventListener public void onUserChange(CanalEntry.Entry entry) { if (entry.getEntryType() == EntryType.ROWDATA) { RowChange rowChange = RowChange.parseFrom(entry.getStoreValue()); for (RowData rowData : rowChange.getRowDatasList()) { String userId = getColumnValue(rowData, "id"); String key = "user:" + userId; // 删除缓存 cache.delete(key); } } } } ``` ## 分布式数据库 ### 数据库分类  *图:分布式数据库三类:分片中间件、NewSQL、NoSQL* ``` ┌─────────────────────────────────────────────────────────────┐ │ 分布式数据库分类 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 传统关系型数据库 + 分片中间件 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ MySQL + ShardingSphere / MyCat │ │ │ │ - 应用层分片 │ │ │ │ - 需要手动管理分片规则 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ NewSQL 数据库 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ TiDB, CockroachDB, YugabyteDB │ │ │ │ - 兼容 SQL,支持 ACID │ │ │ │ - 自动分片和负载均衡 │ │ │ │ - 分布式事务 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ NoSQL 数据库 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ Cassandra, MongoDB, DynamoDB │ │ │ │ - 灵活的数据模型 │ │ │ │ - 高可用,水平扩展 │ │ │ │ - 通常是最终一致性 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### TiDB 架构  *图:TiDB 的 SQL 层、PD Cluster 与 TiKV* ``` ┌─────────────────────────────────────────────────────────────┐ │ TiDB 架构 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ TiDB Server │ │ │ │ (SQL 层,无状态) │ │ │ │ - SQL 解析、优化、执行 │ │ │ │ - 兼容 MySQL 协议 │ │ │ └───────────────────────┬─────────────────────────────┘ │ │ │ │ │ ┌───────────────────────▼─────────────────────────────┐ │ │ │ PD Cluster │ │ │ │ (Placement Driver) │ │ │ │ - 元数据管理 │ │ │ │ - 数据调度 │ │ │ │ - 分配全局 ID 和事务 ID │ │ │ └───────────────────────┬─────────────────────────────┘ │ │ │ │ │ ┌───────────────────────▼─────────────────────────────┐ │ │ │ TiKV Cluster │ │ │ │ (分布式 KV 存储) │ │ │ │ - 数据持久化 │ │ │ │ - Raft 协议保证一致性 │ │ │ │ - 自动分片(Region) │ │ │ │ │ │ │ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ │ │ │ │Region 1│ │Region 2│ │Region 3│ │Region N│ │ │ │ │ └────────┘ └────────┘ └────────┘ └────────┘ │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### CockroachDB 架构  *图:CockroachDB 四层架构与各层职责* ``` ┌─────────────────────────────────────────────────────────────┐ │ CockroachDB 架构 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ SQL Layer │ │ │ │ - SQL 解析和执行 │ │ │ │ - 兼容 PostgreSQL 协议 │ │ │ └────────────────────────┬─────────────────────────────┘ │ │ │ │ │ ┌────────────────────────▼─────────────────────────────┐ │ │ │ Transactional KV Layer │ │ │ │ - 分布式事务(Serializable 隔离级别) │ │ │ │ - MVCC │ │ │ └────────────────────────┬─────────────────────────────┘ │ │ │ │ │ ┌────────────────────────▼─────────────────────────────┐ │ │ │ Distribution Layer │ │ │ │ - Range 分片 │ │ │ │ - Raft 复制 │ │ │ │ - 自动负载均衡 │ │ │ └────────────────────────┬─────────────────────────────┘ │ │ │ │ │ ┌────────────────────────▼─────────────────────────────┐ │ │ │ Storage Layer │ │ │ │ - RocksDB / Pebble │ │ │ └──────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### Cassandra 架构  *图:Cassandra 的无中心架构与可调一致性级别* ``` ┌─────────────────────────────────────────────────────────────┐ │ Cassandra 架构 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 无中心架构(Peer-to-Peer) │ │ │ │ ┌─────────┐ │ │ │ Node A │ │ │ └────┬────┘ │ │ │ │ │ ┌────────┼────────┐ │ │ │ │ │ │ │ ▼ ▼ ▼ │ │ ┌──────┐ ┌──────┐ ┌──────┐ │ │ │Node B│─│Node C│─│Node D│ │ │ └──────┘ └──────┘ └──────┘ │ │ │ │ 特点: │ │ - 一致性哈希分布数据 │ │ - 可调一致性级别(ONE, QUORUM, ALL) │ │ - 最终一致性 │ │ - 高可用,无单点故障 │ │ │ │ 一致性级别: │ │ ┌────────────────────────────────────────────────────┐ │ │ │ ONE: 写入/读取 1 个节点即返回 │ │ │ │ QUORUM: 写入/读取 (N/2 + 1) 个节点 │ │ │ │ ALL: 写入/读取所有节点 │ │ │ └────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### NewSQL vs NoSQL | 对比项 | NewSQL (TiDB等) | NoSQL (Cassandra等) | |--------|-----------------|---------------------| | 数据模型 | 关系型,SQL | 灵活(KV、文档、列族) | | 事务 | 支持 ACID | 通常不支持或有限支持 | | 一致性 | 强一致性 | 可调,通常最终一致 | | 扩展性 | 水平扩展 | 水平扩展 | | 查询 | 完整 SQL | 简单查询,无 JOIN | | 适用场景 | 需要 SQL 和事务 | 高写入,简单查询 | ### 分布式数据库选型  *图:按 SQL、数据模型、一致性、读写比例选型* ``` ┌─────────────────────────────────────────────────────────────┐ │ 选型指南 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 需要 SQL 和 ACID 事务? │ │ ├── 是 → NewSQL (TiDB, CockroachDB) │ │ │ │ │ └── 否 → 继续判断... │ │ │ │ 数据模型? │ │ ├── Key-Value → Redis, DynamoDB │ │ ├── 文档型 → MongoDB │ │ ├── 列族 → Cassandra, HBase │ │ └── 图数据 → Neo4j │ │ │ │ 一致性要求? │ │ ├── 强一致性 → TiDB, CockroachDB, etcd │ │ └── 最终一致性 → Cassandra, DynamoDB │ │ │ │ 读写比例? │ │ ├── 读多写少 → MongoDB, 缓存 │ │ └── 写多读少 → Cassandra, Kafka │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ## 实战建议 ### 缓存设计最佳实践 ``` 1. 缓存 Key 设计 - 使用业务前缀:user:1001, order:2001 - 避免大 Key:单个 Key 不超过 10KB - 设置过期时间:防止内存溢出 2. 缓存穿透 - 空值缓存:查不到也缓存空结果 - 布隆过滤器:提前过滤不存在的请求 3. 缓存雪崩 - 随机过期时间:避免同时失效 - 多级缓存:本地缓存 + 分布式缓存 4. 缓存击穿 - 互斥锁:只有一个请求去加载 - 永不过期 + 异步更新 ``` ```java // 防止缓存穿透 @Service public class CachePenetrationGuard { @Autowired private BloomFilter<String> bloomFilter; @Autowired private RedisTemplate<String, Object> cache; public User getUser(String userId) { // 1. 布隆过滤器判断 if (!bloomFilter.mightContain(userId)) { return null; // 一定不存在 } String key = "user:" + userId; // 2. 查缓存 Object cached = cache.opsForValue().get(key); if (cached != null) { if (cached instanceof NullValue) { return null; // 空值缓存 } return (User) cached; } // 3. 查数据库 User user = userRepository.findById(userId).orElse(null); // 4. 写缓存(包括空值) if (user != null) { cache.opsForValue().set(key, user, 30, TimeUnit.MINUTES); } else { // 缓存空值,短过期时间 cache.opsForValue().set(key, new NullValue(), 5, TimeUnit.MINUTES); } return user; } } // 防止缓存击穿 @Service public class CacheBreakdownGuard { @Autowired private RedissonClient redisson; public User getHotUser(String userId) { String key = "hot_user:" + userId; String lockKey = "lock:" + key; // 1. 查缓存 User user = (User) cache.opsForValue().get(key); if (user != null) { return user; } // 2. 加锁 RLock lock = redisson.getLock(lockKey); try { lock.lock(10, TimeUnit.SECONDS); // 3. 双重检查 user = (User) cache.opsForValue().get(key); if (user != null) { return user; } // 4. 查数据库 user = userRepository.findById(userId).orElse(null); // 5. 写缓存 if (user != null) { cache.opsForValue().set(key, user, 30, TimeUnit.MINUTES); } return user; } finally { lock.unlock(); } } } ``` ## 本章小结 - **Redis Cluster**:16384 槽位,自动分片,主从复制 - **缓存模式**:Cache-Aside、Read/Write Through、Write Behind - **缓存一致性**:延迟双删、Binlog 订阅、分布式锁 - **NewSQL**:TiDB、CockroachDB,兼容 SQL 的分布式数据库 - **NoSQL**:Cassandra、MongoDB,灵活模型,高可用 - **选型原则**:根据数据模型、一致性、读写比例选择 ## 思考题 1. Cache-Aside 模式中,为什么是「删除缓存」而不是「更新缓存」? 2. Redis Cluster 的槽位迁移是如何保证数据一致性的? 3. TiDB 是如何实现分布式事务的?与传统 2PC 有什么区别? ## QA ### Q1:Cache-Aside 模式中,为什么是「删除缓存」而不是「更新缓存」? 因为更新缓存往往比删除缓存更难保证正确。数据库更新后,缓存里到底有哪些键受影响、是否有多种聚合视图、更新顺序会不会乱,都不容易控制;而删除缓存简单很多,只要把旧值删掉,后续读请求自然会从数据库加载最新值并回填缓存。工程上“更新 DB 后删除缓存”是更稳妥的默认策略。 ### Q2:Redis Cluster 的槽位迁移是如何保证数据一致性的? Redis Cluster 迁移槽位时不是一次性粗暴切换,而是分阶段进行。目标节点先导入槽位,源节点标记该槽位正在迁出,迁移过程中客户端可能收到 `ASK` 重定向去访问目标节点;等槽位上的 key 迁完后,再正式更新槽位归属,后续客户端收到的是 `MOVED`。这种“迁移中可重定向、迁完后再正式切换”的机制,保证了槽位迁移期间请求仍然能被正确路由。 ### Q3:TiDB 是如何实现分布式事务的?与传统 2PC 有什么区别? TiDB 的事务底层建立在 TiKV 的 MVCC 和 Percolator 模型之上。它会先向 PD 获取全局时间戳作为事务版本,再在提交时执行两阶段提交:先对主键和相关数据加锁预写(prewrite),再提交主键,最后异步提交其他键。和传统 XA/数据库 2PC 相比,它不依赖数据库层的通用 XA 接口,而是运行在分布式 KV 存储之上,并结合全局时间戳、乐观/悲观事务、1PC、Async Commit 等优化手段,尽量减少锁持有时间和跨节点提交开销。 ---
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入