多个客户端连接
     │
     ▼
┌─────────────┐
│  epoll_wait │  ← 一个系统调用，同时监听所有 socket
│  (阻塞等待)  │
└──────┬──────┘
       │ 有事件到达
       ▼
┌─────────────┐
│  事件分发器  │  ← 把就绪的 socket 放进队列
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  命令处理器  │  ← 一个一个串行执行（单线程核心）
└─────────────┘

struct sdshdr {
    int len;    // 已用长度
    int free;   // 剩余空间
    char buf[]; // 实际数据
}

┌─────────────────────────┐
│      dictht[0]          │  ← 当前使用的哈希表
│  [0] → entry → entry    │
│  [1] → null             │
│  [2] → entry → null     │
│  [3] → entry → entry → ..│
│      dictht[1]          │  ← rehash 时的新表（空表时不用）
│      (rehash 中使用)     │
└─────────────────────────┘

// 对应到 Java 中如何使用 Hash
// 底层是 dict，元素少时用 ziplist 压缩存储（后面讲）
stringRedisTemplate.opsForHash().put("user:10001", "name", "张三");
// 这个过程在 Redis 内部：
// 1. 找一个 bucket
// 2. 遍历链表找到 field
// 3. 更新值
// 4. 如果正在 rehash，顺便搬一小批数据

┌────────┬────────┬────────┬────────┬──────────┐
│zlbytes │zltail  │zllen   │entry1  │entry2... │
│(总字节)│(尾偏移)│(元素数)│        │          │
└────────┴────────┴────────┴────────┴──────────┘

hash-max-ziplist-entries 512   # 元素数 ≤ 512
hash-max-ziplist-value 64      # 单个 value ≤ 64 字节

┌───────┐    ┌───────┐    ┌───────┐
│ziplist│◄──►│ziplist│◄──►│ziplist│
│(节点1)│    │(节点2)│    │(节点3)│
└───────┘    └───────┘    └───────┘

list-max-ziplist-size -2  # 每个 ziplist 最大 8KB
list-compress-depth 1     # 两端各 1 个节点不压缩，中间压缩

Level 4:  1 ───────────────────────────────► 100
Level 3:  1 ──────────────► 50 ────────────► 100
Level 2:  1 ────► 20 ────► 50 ────► 80 ───► 100
Level 1:  1 → 10 → 20 → 30 → 50 → 60 → 80 → 90 → 100

// ZSet 的 ZADD 在底层做了什么
stringRedisTemplate.opsForZSet().add("rank", "player1", 100);

// 1. 在 dict 中记录: "player1" → 100（O(1) 查找）
// 2. 在 skiplist 中插入节点（O(log N)），按 score 排序
// 3. score 相同按 member 字典序排

save 900 1    # 900 秒内至少 1 次修改
save 300 10   # 300 秒内至少 10 次修改
save 60 10000 # 60 秒内至少 10000 次修改

┌────────┐
│ Redis  │──fork()──► 子进程
│ 主进程  │            │
└────────┘            ▼
                 ┌──────────┐
                 │ 写 RDB 文件│  ← 子进程写磁盘，主进程继续处理请求
                 └──────────┘

appendonly yes
appendfsync everysec  # 每秒刷盘一次（推荐）
# appendfsync always  # 每条都刷（最安全但最慢）
# appendfsync no      # 交给操作系统决定（有丢失风险）

原 AOF: SET count 1 → INCR count → INCR count → INCR count
重写后: SET count 4

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

┌──────────────┬─────────────────┐
│ RDB 格式的快照│ AOF 格式的增量命令│
│ (全量数据)    │ (快照后的写操作)  │
└──────────────┴─────────────────┘

     ┌─────────┐
     │  Master  │  ← 处理所有写请求
     └────┬────┘
    ┌─────┴─────┐
    ▼           ▼
┌──────┐   ┌──────┐
│Slave1│   │Slave2│  ← 处理读请求，分担压力
└──────┘   └──────┘

1. Slave 连上 Master，发送 PSYNC 命令
2. Master fork 子进程生成 RDB，同时把新命令写入 replication buffer
3. Master 把 RDB 发给 Slave
4. Slave 清空旧数据，加载 RDB
5. Master 把 buffer 里的增量命令发给 Slave，Slave 执行
6. 此后 Master 每条写命令都同步给 Slave（异步，近实时）

repl-backlog-size 64mb   # 缓冲区大小，越大越能容忍断线
repl-backlog-ttl 3600    # 所有 Slave 都断开后，多久释放 backlog

┌──────────┐  ┌──────────┐  ┌──────────┐
│Sentinel 1│  │Sentinel 2│  │Sentinel 3│  ← 至少 3 台，互相通信
└────┬─────┘  └────┬─────┘  └────┬─────┘
     │             │             │
     └─────────────┼─────────────┘
                   │ 监控
         ┌─────────┴─────────┐
         │   Master + Slave  │
         └───────────────────┘

1. Sentinel 定期 PING Master
2. 超过 down-after-milliseconds 没响应 → 主观下线（SDOWN）
3. 多个 Sentinel 达成共识（quorum）→ 客观下线（ODOWN）
4. Sentinel 选举出一个 Leader
5. Leader 从 Slave 中选一个升级为新 Master
6. 通知其他 Slave 复制新 Master
7. 通知客户端连接新 Master

1. 优先级高的（slave-priority 值小的）
2. 复制偏移量大的（数据最新的）
3. runid 小的（兜底规则）

// Lettuce 连接哨兵模式
@Bean
public RedisConnectionFactory redisConnectionFactory() {
    RedisSentinelConfiguration config = new RedisSentinelConfiguration()
        .master("mymaster")
        .sentinel("192.168.1.10", 26379)
        .sentinel("192.168.1.11", 26379)
        .sentinel("192.168.1.12", 26379);
    config.setPassword("123456");
    return new LettuceConnectionFactory(config);
}

CRC16(key) % 16384 → 落在哪个节点

客户端 → Node A: GET user:1001
Node A → 客户端: MOVED 12360 192.168.1.11:6379
客户端 → Node B: GET user:1001
Node B → 客户端: "张三"

1. 目标节点: CLUSTER SETSLOT <slot> IMPORTING <source_id>
2. 源节点:   CLUSTER SETSLOT <slot> MIGRATING <target_id>
3. 源节点:   CLUSTER GETKEYSINSLOT <slot> <count>  → 逐个 MIGRATE
4. 全部迁完后，向所有节点广播槽位变更

spring:
  data:
    redis:
      cluster:
        nodes:
          - 192.168.1.10:6379
          - 192.168.1.11:6379
          - 192.168.1.12:6379
          - 192.168.1.13:6379
          - 192.168.1.14:6379
          - 192.168.1.15:6379
        max-redirects: 3  # 最多重定向次数

每秒执行 10 次：
1. 从设置了过期时间的 key 中随机取 20 个
2. 删除其中已过期的
3. 如果过期比例 > 25%，重复步骤 1
4. 每次执行不超过 25ms（避免阻塞）

maxmemory 4gb                      # 设为物理内存的 75%
maxmemory-policy allkeys-lru       # 通用缓存场景

随机取 N 个 key（默认 5，可配置 maxmemory-samples）
淘汰其中 idle 时间最长的那个

// Redis 事务——这个代码主要是为了理解概念，实际很少用
stringRedisTemplate.setEnableTransactionSupport(true);
stringRedisTemplate.multi();
stringRedisTemplate.opsForValue().set("a", "1");
stringRedisTemplate.opsForValue().increment("a"); // a 是字符串，INCR 会报错
stringRedisTemplate.opsForValue().set("b", "2");
stringRedisTemplate.exec(); // 结果：a=1（SET 成功了），INCR 报错但 b 还是被 SET 了

@Component
public class StockLuaService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // Lua 脚本：原子性的查询 + 扣减
    private static final String DEDUCT_SCRIPT = """
        local key = KEYS[1]
        local amount = tonumber(ARGV[1])
        local stock = tonumber(redis.call('GET', key))
        if stock == nil then
            return -1  -- key 不存在
        end
        if stock < amount then
            return -2  -- 库存不足
        end
        redis.call('DECRBY', key, amount)
        return stock - amount  -- 返回扣减后的库存
        """;

    // 预编译脚本（复用 SHA 执行，减少网络传输）
    private final RedisScript<Long> script;

    public StockLuaService() {
        this.script = new DefaultRedisScript<>(DEDUCT_SCRIPT, Long.class);
    }

    public long deduct(Long skuId, int amount) {
        String key = "stock:sku:" + skuId;
        Long result = stringRedisTemplate.execute(
            script,
            Collections.singletonList(key),
            String.valueOf(amount)
        );
        return result != null ? result : -1;
    }
}

客户端                Redis
  │                     │
  │───── SET a 1 ──────►│  RTT 0.1ms
  │◄───── OK ────────── │
  │───── SET b 2 ──────►│  RTT 0.1ms
  │◄───── OK ────────── │
  │───── SET c 3 ──────►│  RTT 0.1ms
  │◄───── OK ────────── │
     10000 次
     = 10000 × 0.1ms = 1 秒（光网络就 1 秒）

客户端                      Redis
  │                           │
  │── SET a 1                 │
  │── SET b 2    ────────────►│  一次网络发送
  │── SET c 3                 │  一次网络接收
  │◄── OK ──────────────────  │
  │◄── OK ───                   │
  │◄── OK ──────                │
     10000 次 ≈ 10ms

public void batchSet(Map<String, String> kvMap) {
    stringRedisTemplate.executePipelined((RedisCallback<Object>) connection -> {
        StringRedisSerializer serializer = (StringRedisSerializer) stringRedisTemplate.getStringSerializer();
        for (Map.Entry<String, String> entry : kvMap.entrySet()) {
            connection.set(
                serializer.serialize(entry.getKey()),
                serializer.serialize(entry.getValue())
            );
        }
        return null; // pipeline 模式下返回值无意义
    });
}

# 查看慢查询配置
redis-cli CONFIG GET slowlog*

# 设置慢查询阈值（微秒），超过这个时间的命令会被记录
redis-cli CONFIG SET slowlog-log-slower-than 10000  # 10ms

# 查看最近 10 条慢查询
redis-cli SLOWLOG GET 10

1) 1) (integer) 12345           # 日志 ID
   2) (integer) 1700000000      # 时间戳
   3) (integer) 15678           # 执行耗时（微秒）
   4) 1) "KEYS"                 # 命令
      2) "user:*"

public Set<String> scanKeys(String pattern) {
    return stringRedisTemplate.execute((RedisCallback<Set<String>>) connection -> {
        Set<String> keys = new HashSet<>();
        Cursor<byte[]> cursor = connection.scan(
            ScanOptions.scanOptions().match(pattern).count(100).build()
        );
        while (cursor.hasNext()) {
            keys.add(new String(cursor.next()));
        }
        return keys;
    });
}

rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command KEYS ""
rename-command CONFIG "CONFIG_b3e2a1"  # 改名，防止被随意调用

# 错误：key 太长的全路径
user:detail:info:by:id:10001:with:full:attributes:version:v2

# 正确：简洁有层次
user:10001

@Bean
public LettuceClientConfigurationBuilderCustomizer lettuceCustomizer() {
    return builder -> builder
        .clientOptions(ClientOptions.builder()
            .autoReconnect(true)           // 自动重连
            .disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
            .socketOptions(SocketOptions.builder()
                .connectTimeout(Duration.ofSeconds(5))
                .keepAlive(true)
                .build())
            .build())
        .clientResources(ClientResources.builder()
            .ioThreadPoolSize(4)           // IO 线程数 = CPU 核数
            .computationThreadPoolSize(4)   // 计算线程数
            .build());
}

你的业务代码
     │
     ▼
 ┌─────────────┐
 │ 本地缓存     │ ← Caffeine，挡住 70% 请求
 │ (Caffeine)   │
 └──────┬──────┘
        │ miss
        ▼
 ┌─────────────┐
 │ 分布式缓存   │ ← Redis Cluster，扛住高并发
 │ (Redis)      │
 └──────┬──────┘
        │ miss
        ▼
 ┌─────────────┐
 │ 数据库       │ ← MySQL，只有极少量请求到这里
 │ (MySQL)      │
 └─────────────┘