1
传统数据库：客户端 → 网络 → 线程池 → 磁盘 I/O → 返回
2
Redis：客户端 → 网络 → 单线程事件循环 → 内存操作 → 返回

1
// SDS（Simple Dynamic String）结构
2
struct sdshdr {
3
    uint8_t len;      // 已使用长度
4
    uint8_t alloc;    // 分配的总空间
5
    uint8_t flags;    // 类型标识
6
    char buf[];       // 字节数组
7
};

1
# Hash 应用示例：购物车
2
HSET cart:user:1001 item:001 2    # 商品 001，数量 2
3
HSET cart:user:1001 item:002 1    # 商品 002，数量 1
4
HGET cart:user:1001 item:001      # 获取商品 001 数量
5
HGETALL cart:user:1001            # 获取整个购物车

1
QuickList 结构：
2
┌─────────────────────────────────────────────┐
3
│  Node 1    │  Node 2    │  Node 3    │ ...  │
4
│  (listpack)│  (listpack)│  (listpack)│      │
5
└─────────────────────────────────────────────┘
6
     ↕            ↕            ↕
7
   双向链表连接各节点

1
# List 应用示例：消息队列
2
LPUSH queue:orders "order:001"    # 生产者：左边推入
3
LPUSH queue:orders "order:002"
4
BRPOP queue:orders 5              # 消费者：右边阻塞弹出

1
SkipList 结构示意：
2

3
Level 4:    1 ──────────────────────────→ 100
4
Level 3:    1 ────────────→ 50 ────────→ 100
5
Level 2:    1 ────→ 25 ───→ 50 ────→ 75 → 100
6
Level 1:    1 → 10 → 25 → 50 → 60 → 75 → 100

1
# Sorted Set 应用示例：排行榜
2
ZADD leaderboard 100 player:001
3
ZADD leaderboard 150 player:002
4
ZADD leaderboard 120 player:003
5
ZREVRANGE leaderboard 0 9 WITHSCORES   # 获取 Top 10

1
# 配置自动触发
2
save 900 1     # 900 秒内有 1 次写操作
3
save 300 10    # 300 秒内有 10 次写操作
4
save 60 10000  # 60 秒内有 10000 次写操作
5

6
# 手动触发
7
SAVE           # 阻塞主进程（不推荐）
8
BGSAVE         # 后台 fork 子进程执行

1
1. Redis 主进程 fork 子进程
2
2. 子进程将内存数据写入临时 RDB 文件
3
3. 写入完成后，原子替换旧 RDB 文件
4
4. 子进程退出

1
写命令 → 写入 AOF 缓冲区 → 根据策略同步到磁盘

1
# 手动触发重写
2
BGREWRITEAOF
3

4
# 自动触发配置
5
auto-aof-rewrite-percentage 100   # 文件比上次重写后增长 100%
6
auto-aof-rewrite-min-size 64mb     # 文件至少 64MB

1
# 开启混合持久化
2
aof-use-rdb-preamble yes

1
┌─────────────────────────────────────────┐
2
│        RDB 格式数据（快照）              │
3
├─────────────────────────────────────────┤
4
│        AOF 格式数据（增量命令）          │
5
└─────────────────────────────────────────┘

1
1. 从节点发送 PSYNC 命令
2
2. 主节点执行 BGSAVE 生成 RDB
3
3. 主节点发送 RDB 给从节点
4
4. 从节点加载 RDB
5
5. 主节点发送增量写命令（replication buffer）

1
replicaof <master-ip> <master-port>   # 从节点配置
2
masterauth <password>                  # 主节点密码
3
replica-read-only yes                  # 从节点只读

1
┌─────────────┐
2
│ Sentinel 1  │──┐
3
├─────────────┤  │    ┌─────────┐
4
│ Sentinel 2  │──┼───→│ Master  │
5
├─────────────┤  │    └─────────┘
6
│ Sentinel 3  │──┘         │
7
└─────────────┘       ┌────┴────┐
8
                      ↓         ↓
9
                 ┌─────────┐ ┌─────────┐
10
                 │ Slave 1 │ │ Slave 2 │
11
                 └─────────┘ └─────────┘

1
16384 个槽位均匀分布在多个节点
2

3
Node A: 0-5460 槽位
4
Node B: 5461-10922 槽位
5
Node C: 10923-16383 槽位
6

7
每个节点负责一部分槽位

1
# 客户端请求
2
SET user:1001 "data"
3
↓
4
CRC16("user:1001") % 16384 = 槽位号
5
↓
6
路由到对应节点

1
客户端 → Redis（不存在）→ 数据库（也不存在）→ 返回空
2
                        ↑
3
                        每次都穿透

1
// 初始化时预热所有存在的 key
2
BloomFilter<String> filter = BloomFilter.create(Funnels.stringFunnel(), 1000000);
3
for (String key : allKeys) {
4
    filter.put(key);
5
}
6

7
// 查询时先判断
8
if (!filter.mightContain(key)) {
9
    return null;  // 一定不存在，直接返回
10
}
11
// 可能存在，继续查询缓存和数据库

1
# 查询数据库为空时，也缓存一个空值
2
SET nonexistent_key "" EX 60   # 设置较短过期时间

1
热点 key 过期
2
    ↓
3
并发请求 → 缓存未命中 → 全部打到数据库

1
public String getWithLock(String key) {
2
    String value = redis.get(key);
3
    if (value != null) {
4
        return value;
5
    }
6

7
    // 尝试获取锁
8
    String lockKey = "lock:" + key;
9
    if (redis.setnx(lockKey, "1", 10)) {  // 10 秒超时
10
        try {
11
            // 再次检查缓存（双检）
12
            value = redis.get(key);
13
            if (value == null) {
14
                value = db.query(key);  // 查数据库
15
                redis.set(key, value, 3600);  // 写入缓存
16
            }
17
        } finally {
18
            redis.del(lockKey);  // 释放锁
19
        }
20
    } else {
21
        // 等待后重试
22
        Thread.sleep(50);
23
        return getWithLock(key);
24
    }
25
    return value;
26
}

1
# 物理上不设置过期时间
2
SET hot_key "data"
3

4
# 数据中包含逻辑过期时间
5
{
6
    "data": "...",
7
    "expireTime": 1710000000  # 逻辑过期时间
8
}
9

10
# 后台线程定期检查并异步更新

1
Redis 宕机或大量 key 同时过期
2
         ↓
3
请求 → 缓存失效 → 全部打到数据库 → 数据库崩溃

1
// 基础过期时间 + 随机偏移
2
int baseExpire = 3600;
3
int randomExpire = baseExpire + new Random().nextInt(300);  // 1 小时 + 0~5 分钟
4
redis.set(key, value, randomExpire);

1
Redis Cluster 或 Sentinel 模式
2
         ↓
3
主节点故障 → 自动切换到从节点

1
// 使用 Sentinel 或 Hystrix 进行熔断
2
@SentinelResource(value = "getData", fallback = "getDataFallback")
3
public String getData(String key) {
4
    return cacheService.get(key);
5
}
6

7
public String getDataFallback(String key) {
8
    return "系统繁忙，请稍后重试";  // 降级返回
9
}

1
// 系统启动时预热热点数据
2
@PostConstruct
3
public void warmUp() {
4
    List<String> hotKeys = getHotKeys();
5
    for (String key : hotKeys) {
6
        String value = db.query(key);
7
        redis.set(key, value, getRandomExpire());
8
    }
9
}

1
# 加锁
2
SET lock:resource unique_value NX PX 30000   # NX 不存在才设置，PX 过期时间
3

4
# 解锁（Lua 脚本保证原子性）
5
if redis.call("GET", KEYS[1]) == ARGV[1] then
6
    return redis.call("DEL", KEYS[1])
7
else
8
    return 0
9
end

1
┌─────────┐
2
│ Redis 1 │ ← 加锁成功
3
├─────────┤
4
│ Redis 2 │ ← 加锁成功
5
├─────────┤
6
│ Redis 3 │ ← 加锁失败
7
├─────────┤
8
│ Redis 4 │ ← 加锁成功
9
├─────────┤
10
│ Redis 5 │ ← 加锁成功
11
└─────────┘
12

13
5 个节点，4 个成功 → 获得锁

1
RedissonClient client1 = Redisson.create(config1);
2
RedissonClient client2 = Redisson.create(config2);
3
RedissonClient client3 = Redisson.create(config3);
4

5
RedissonMultiLock lock = new RedissonMultiLock(client1, client2, client3);
6
lock.lock();
7
try {
8
    // 执行业务逻辑
9
} finally {
10
    lock.unlock();
11
}

1
// 可重入锁
2
RLock lock = redisson.getLock("myLock");
3
lock.lock();
4
try {
5
    // 业务逻辑
6
} finally {
7
    lock.unlock();
8
}
9

10
// 公平锁
11
RLock fairLock = redisson.getFairLock("myFairLock");
12

13
// 读写锁
14
RReadWriteLock rwLock = redisson.getReadWriteLock("myRWLock");
15
rwLock.readLock().lock();
16
rwLock.writeLock().lock();
17

18
// 联锁（多锁组合）
19
RLock lock1 = redisson.getLock("lock1");
20
RLock lock2 = redisson.getLock("lock2");
21
RedissonMultiLock multiLock = new RedissonMultiLock(lock1, lock2);

1
// 默认 30 秒过期，看门狗每 10 秒续期
2
RLock lock = redisson.getLock("myLock");
3
lock.lock();  // 自动续期
4

5
// 指定过期时间（不启用看门狗）
6
lock.lock(10, TimeUnit.SECONDS);

1
maxmemory 4gb                    # 设置最大内存
2
maxmemory-policy allkeys-lru     # 设置淘汰策略

1
访问顺序：A → B → C → A → D
2
内存满时淘汰：B（最久未被访问）
3

4
LRU 队列：
5
[最近访问] D → A → C → B [最久访问]

1
访问统计：A(3次) B(1次) C(2次) D(2次)
2
内存满时淘汰：B（访问次数最少）

1
# 配置 LFU 相关参数
2
lfu-log-factor 10      # 计数器增长因子
3
lfu-decay-time 1       # 衰减时间（分钟）

1
# 小对象使用 Hash 优化
2
# 原本：多个 String
3
SET user:1001:name "Alice"
4
SET user:1001:age "25"
5

6
# 优化：单个 Hash
7
HSET user:1001 name "Alice" age "25"

1
# 配置压缩阈值
2
hash-max-listpack-entries 512
3
hash-max-listpack-value 64
4
zset-max-listpack-entries 128
5
zset-max-listpack-value 64

1
# 避免数据堆积
2
SET key value EX 3600  # 1 小时过期

1
# 检查大 Key
2
redis-cli --bigkeys
3

4
# 拆分大 Key
5
# 原：一个大 Hash
6
HSET large:hash field1 value1 field2 value2 ... field1000 value1000
7

8
# 拆分：多个小 Hash
9
HSET large:hash:1 field1 value1
10
HSET large:hash:2 field2 value2