返回学习记录

Learning archive

Redis 学习记录

梳理 Redis 的核心数据结构、常用命令、持久化、高可用与典型实战场景。

2026年10月30日
  • Redis
  • 缓存
  • 学习笔记

Redis 学习记录#

本文档记录 Redis 的核心知识点、常用命令示例、底层原理与实战应用场景。 适合作为学习笔记、复习资料与面试准备。


一、Redis 简介#

Redis(Remote Dictionary Server) 是一个开源的、基于内存的 键值(Key-Value)数据库,用 C 语言编写。

1.1 核心特点#

  • 基于内存: 数据存于内存,读写速度极快(10 万+ QPS)
  • 支持持久化: RDB 和 AOF 两种方式,防止数据丢失
  • 多种数据结构: String、Hash、List、Set、ZSet 等
  • 单线程模型: 命令执行是单线程的(网络 IO 多路复用),天然原子性
  • 高可用: 支持主从复制、哨兵模式、集群模式
  • 丰富功能: 事务、发布订阅、Lua 脚本、过期策略、分布式锁

1.2 为什么这么快?#

  1. 数据存储在内存中,读写无需磁盘 IO
  2. 采用单线程模型,避免了多线程上下文切换和锁竞争
  3. 使用 IO 多路复用(epoll)处理大量并发连接
  4. 底层数据结构优化(如 SDS、跳表、压缩列表等)

1.3 应用场景#

场景说明
缓存热点数据缓存,减轻数据库压力
计数器文章阅读量、点赞数(INCR)
排行榜ZSet 实现实时排名
分布式锁SET key value NX PX
会话共享存储用户 Session
消息队列List / Stream 实现简单队列
限流计数器 + 过期时间

二、安装与连接#

2.1 安装(Windows / Linux)#

# Linux(以 Ubuntu 为例)
sudo apt update
sudo apt install redis-server

# 启动服务
redis-server

# 客户端连接
redis-cli

# 测试
127.0.0.1:6379> ping
PONG

2.2 常用启动配置#

# 指定配置文件启动
redis-server /etc/redis/redis.conf

# 指定端口和密码启动
redis-server --port 6380 --requirepass "123456"

# 客户端连接指定端口和密码
redis-cli -p 6380 -a 123456

2.3 常用基础命令#

PING                 # 测试连接
SELECT 1             # 切换数据库(默认 0-15 共 16 个库)
DBSIZE               # 当前库 key 数量
KEYS *               # 查看所有 key(生产环境慎用!)
SCAN 0 MATCH user:* COUNT 100   # 渐进式遍历(推荐)
EXISTS key           # 判断 key 是否存在
TYPE key             # 查看 key 的类型
DEL key              # 删除 key
EXPIRE key 60        # 设置过期时间(秒)
TTL key              # 查看剩余过期时间(-1 永不过期,-2 不存在)
PERSIST key          # 移除过期时间
FLUSHDB              # 清空当前库(慎用)
FLUSHALL             # 清空所有库(慎用)

注意: 生产环境禁用 KEYS *,它会阻塞 Redis。应使用 SCAN 遍历。


三、核心数据类型#

Redis 有 5 种基本数据类型:String、Hash、List、Set、ZSet(有序集合)。

3.1 String(字符串)#

最基础的类型,可以存储字符串、数字、二进制数据。最大 512MB。

# 常用命令
SET name "张三"              # 设置值
GET name                     # 获取值
SETEX code 60 "8888"         # 设置值并指定过期时间(秒)
SETNX lock "1"               # key 不存在才设置(分布式锁基础)
MSET k1 v1 k2 v2             # 批量设置
MGET k1 k2                   # 批量获取
STRLEN name                  # 字符串长度
APPEND name "老师"           # 追加字符串

# 数字操作(原子性)
SET count 0
INCR count                   # 自增 1
INCRBY count 10              # 增加 10
DECR count                   # 自减 1
DECRBY count 5               # 减少 5

应用场景: 缓存、计数器、分布式锁、Session 共享。

示例:分布式锁

SET lock:order "user_123" NX PX 30000
# NX:key 不存在才设置成功
# PX 30000:30 秒后自动过期

3.2 Hash(哈希)#

存储键值对集合,类似 Java 中的 Map<String, Map<String, String>>,适合存储对象。

# 常用命令
HSET user:1 name "张三" age 20        # 设置字段
HGET user:1 name                     # 获取单个字段
HMGET user:1 name age                # 获取多个字段
HGETALL user:1                       # 获取所有字段和值
HKEYS user:1                         # 获取所有字段名
HVALS user:1                         # 获取所有字段值
HLEN user:1                          # 字段数量
HEXISTS user:1 name                  # 判断字段是否存在
HDEL user:1 age                      # 删除字段
HINCRBY user:1 age 1                 # 字段自增

应用场景: 存储对象(如用户信息)、购物车。

示例:

HSET cart:1001 item:1 "iPhone" item:2 "MacBook"
HINCRBY cart:1001 count:1 1       # 商品数量 +1

3.3 List(列表)#

有序、可重复的字符串列表,底层是双向链表(快速列表 quicklist)。

# 常用命令
LPUSH list a b c          # 左侧插入(c 在头)
RPUSH list d e            # 右侧插入
LRANGE list 0 -1          # 查看全部元素
LPOP list                 # 左侧弹出
RPOP list                 # 右侧弹出
LLEN list                 # 列表长度
LINDEX list 0             # 按索引获取
LREM list 1 a             # 删除 1 个值为 a 的元素
LTRIM list 0 9            # 保留 0-9 索引范围

应用场景: 消息队列、最新列表、栈/队列。

示例:简单的消息队列

# 生产者
LPUSH queue "task1"
# 消费者(阻塞式获取,timeout 5 秒)
BRPOP queue 5

3.4 Set(集合)#

无序、不可重复的字符串集合,支持交集、并集、差集运算。

# 常用命令
SADD tag java python go          # 添加元素
SMEMBERS tag                     # 查看所有成员
SISMEMBER tag java               # 判断是否包含
SCARD tag                        # 元素数量
SREM tag python                  # 删除元素
SPOP tag                         # 随机弹出一个元素

# 集合运算
SINTER set1 set2                 # 交集
SUNION set1 set2                 # 并集
SDIFF set1 set2                  # 差集

应用场景: 标签、共同好友、抽奖、去重。

示例:共同好友

SADD user:1:friends "2" "3" "4"
SADD user:2:friends "3" "4" "5"
SINTER user:1:friends user:2:friends   # 共同好友:3, 4

3.5 ZSet(有序集合)#

集合元素唯一,每个元素关联一个 score(分值),按 score 排序。底层是跳表 + 哈希表。

# 常用命令
ZADD rank 100 "张三" 200 "李四" 150 "王五"   # 添加元素和分值
ZRANGE rank 0 -1 WITHSCORES                  # 按分值升序
ZREVRANGE rank 0 -1 WITHSCORES               # 按分值降序
ZSCORE rank "张三"                           # 查看某元素分值
ZINCRBY rank 10 "张三"                       # 分值增加
ZRANK rank "张三"                            # 升序排名(从 0 开始)
ZREVRANK rank "张三"                         # 降序排名
ZCARD rank                                   # 元素数量
ZCOUNT rank 100 200                          # 分值区间内数量
ZREM rank "王五"                             # 删除元素

应用场景: 排行榜、延时队列、带权重的任务调度。

示例:实时排行榜

# 玩家得分
ZADD game:rank 9500 "player1" 8800 "player2" 9200 "player3"

# 前 10 名
ZREVRANGE game:rank 0 9 WITHSCORES

# 查看某玩家排名(从 0 开始)
ZREVRANK game:rank "player2"

3.6 数据结构对比总结#

类型结构特点典型场景
String字符串简单、原子操作缓存、计数、锁
Hash哈希表存储对象、字段级操作用户信息、购物车
List双向链表有序、可重复队列、栈、最新列表
Set哈希表无序、去重、集合运算标签、共同好友、抽奖
ZSet跳表 + 哈希表有序、可排序排行榜、延时队列

3.7 高级数据类型#

类型说明场景
Bitmap位操作签到、活跃用户统计
HyperLogLog基数统计(误差 0.81%)UV 统计
GEO地理位置附近的人
Stream消息流(支持消费组)消息队列

示例:签到(Bitmap)

SETBIT sign:2024-10:user1 0 1     # 第 1 天签到
SETBIT sign:2024-10:user1 1 1     # 第 2 天签到
BITCOUNT sign:2024-10:user1       # 统计签到天数

示例:UV 统计(HyperLogLog)

PFADD uv:2024-10-01 "user1" "user2"
PFCOUNT uv:2024-10-01             # 统计独立访客数

四、持久化机制#

Redis 是内存数据库,重启会丢失数据,因此需要持久化。

4.1 RDB(Redis Database)#

原理: 定时将内存数据快照保存到磁盘(dump.rdb 文件)。

触发方式:

  • 手动:SAVE(阻塞)、BGSAVE(后台执行,fork 子进程)
  • 自动:配置 save 900 1(900 秒内至少 1 次修改则触发)

优点:

  • 文件紧凑,适合备份
  • 恢复速度快

缺点:

  • 可能丢失最后一次快照之后的数据
  • fork 时占用内存(写时复制)

4.2 AOF(Append Only File)#

原理: 将每个写命令追加到日志文件(appendonly.aof),重启时重放命令恢复数据。

刷盘策略:

策略说明安全性性能
appendfsync always每条命令都刷盘最高最低
appendfsync everysec每秒刷盘(默认)较高较高
appendfsync no由操作系统决定最低最高

优点:

  • 数据丢失少(最多 1 秒)
  • 日志可读,可修复

缺点:

  • 文件体积大
  • 恢复速度慢

4.3 混合持久化(Redis 4.0+)#

  • 结合 RDB + AOF:AOF 文件开头是 RDB 格式快照,后续是 AOF 增量命令
  • 配置:aof-use-rdb-preamble yes(默认开启)
  • 兼顾恢复速度与数据完整性

4.4 对比#

对比项RDBAOF
数据丢失可能丢失较多最多 1 秒(everysec)
文件大小小大
恢复速度快慢
性能影响fork 时较大写操作有额外开销

实践建议: 一般同时开启 RDB 和 AOF,用 RDB 做备份,用 AOF 保证数据安全。


五、过期策略与内存淘汰#

5.1 过期删除策略#

Redis 采用惰性删除 + 定期删除结合:

  • 惰性删除: 访问 key 时才检查是否过期,过期则删除
  • 定期删除: 每隔一段时间随机抽查一部分 key,删除过期的

为什么不立即删除?因为立即删除需要遍历所有 key,开销太大。

5.2 内存淘汰策略(maxmemory-policy)#

当内存达到 maxmemory 限制时,按策略淘汰 key:

策略说明
noeviction不淘汰,写入报错(默认)
allkeys-lru所有 key 中淘汰最近最少使用的
allkeys-lfu所有 key 中淘汰使用频率最低的
volatile-lru设置了过期时间的 key 中淘汰 LRU
volatile-lfu设置了过期时间的 key 中淘汰 LFU
allkeys-random随机淘汰
volatile-ttl优先淘汰即将过期的

常用: 缓存场景推荐 allkeys-lru;有持久化数据时用 volatile-lru。


六、事务与 Lua 脚本#

6.1 事务(MULTI/EXEC)#

MULTI                    # 开启事务
SET name "张三"
INCR count
EXEC                     # 执行(DISCARD 取消)

特点:

  • 命令按顺序执行,期间不会插入其他客户端命令
  • 不支持回滚:某条命令失败,其他命令仍会执行
  • 适合批量执行,但不是严格意义上的原子性事务

6.2 Lua 脚本#

Lua 脚本在 Redis 中原子执行,适合"读取-判断-写入"的复杂逻辑。

-- 分布式锁释放脚本(判断是自己的锁才删除)
if redis.call('get', KEYS[1]) == ARGV[1] then
    return redis.call('del', KEYS[1])
else
    return 0
end
EVAL "return redis.call('set', KEYS[1], ARGV[1])" 1 mykey myvalue

优势: 原子性、减少网络往返、实现复杂逻辑。


七、高可用与集群#

7.1 主从复制(Replication)#

  • 主节点(Master)写,从节点(Slave)读
  • 从节点通过 SLAVEOF 配置主节点
  • 支持读写分离、数据备份
SLAVEOF 127.0.0.1 6379     # 让当前节点成为 6379 的从节点
INFO replication           # 查看复制状态

缺点: 主节点宕机后需要手动切换。

7.2 哨兵模式(Sentinel)#

  • 监控主从节点状态
  • 主节点故障时自动故障转移(选举新主)
  • 客户端通过哨兵获取当前主节点地址

配置示例(sentinel.conf):

sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel failover-timeout mymaster 180000

7.3 集群模式(Cluster)#

  • 数据分片(16384 个哈希槽)
  • 每个节点负责一部分槽位
  • 支持在线扩容、高并发
  • 至少 6 个节点(3 主 3 从)
redis-cli --cluster create \
  127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 \
  127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 \
  --cluster-replicas 1

7.4 三种模式对比#

模式优点缺点
主从复制读写分离、备份无自动故障转移
哨兵模式自动故障转移数据量受单机内存限制
集群模式数据分片、高并发部署复杂,多 key 操作受限

八、缓存三大问题#

8.1 缓存穿透(Cache Penetration)#

问题: 查询一个不存在的数据,缓存不命中,请求直达数据库,导致数据库压力过大。

解决方案:

  1. 缓存空值: 查不到也缓存一个空值,设置较短过期时间
  2. 布隆过滤器: 用布隆过滤器拦截不存在的 key
# 缓存空值示例
SET user:999 "" EX 60    # 不存在的用户缓存空字符串,60 秒过期

8.2 缓存击穿(Cache Breakdown)#

问题: 某个热点 key 过期的瞬间,大量请求同时打到数据库。

解决方案:

  1. 互斥锁: 只让一个请求去查数据库,其他等待
  2. 逻辑过期: 不设置真正的过期时间,用字段标记过期,异步更新

8.3 缓存雪崩(Cache Avalanche)#

问题: 大量 key 同时过期,或 Redis 宕机,导致所有请求打到数据库。

解决方案:

  1. 过期时间加随机值: 避免同时过期
  2. Redis 高可用: 主从 + 哨兵 / 集群
  3. 服务降级、限流、熔断

8.4 三者对比#

问题核心原因典型解决
穿透查不存在的数据缓存空值、布隆过滤器
击穿热点 key 过期互斥锁、逻辑过期
雪崩大量 key 同时过期/宕机随机过期时间、高可用

九、实战示例(Java + Spring Boot)#

9.1 引入依赖#

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

9.2 配置文件(application.yml)#

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password: "123456"
    database: 0
    timeout: 3000ms
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0

9.3 RedisTemplate 示例#

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class RedisService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /** 缓存字符串 */
    public void set(String key, String value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /** 获取字符串 */
    public String get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /** 计数器自增 */
    public Long incr(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    /** 分布式锁:SET NX PX */
    public boolean tryLock(String key, String value, long timeoutSeconds) {
        Boolean success = redisTemplate.opsForValue()
                .setIfAbsent(key, value, timeoutSeconds, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    /** 释放锁 */
    public void unlock(String key) {
        redisTemplate.delete(key);
    }
}

9.4 缓存使用示例#

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private RedisService redisService;

    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        String key = "user:" + id;

        // 1. 先查缓存
        String cached = redisService.get(key);
        if (cached != null) {
            return parse(cached); // 反序列化为对象
        }

        // 2. 缓存未命中,查数据库
        User user = userMapper.selectById(id);

        // 3. 写回缓存(注意随机过期时间,防止雪崩)
        if (user != null) {
            long ttl = 3600 + (long) (Math.random() * 600); // 1 小时 ± 10 分钟
            redisService.set(key, toJson(user), ttl, TimeUnit.SECONDS);
        }
        return user;
    }

    private User parse(String json) {
        // JSON 反序列化(如 Jackson)
        return null;
    }

    private String toJson(User user) {
        // JSON 序列化
        return "";
    }
}

9.5 分布式锁完整示例(Lua 脚本释放)#

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Component
public class RedisLock {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final String UNLOCK_SCRIPT =
            "if redis.call('get', KEYS[1]) == ARGV[1] then " +
            "  return redis.call('del', KEYS[1]) " +
            "else return 0 end";

    /** 加锁 */
    public String lock(String key, long timeoutSeconds) {
        String value = UUID.randomUUID().toString(); // 唯一标识,防止误删
        Boolean success = redisTemplate.opsForValue()
                .setIfAbsent(key, value, timeoutSeconds, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success) ? value : null;
    }

    /** 解锁:用 Lua 保证判断和删除的原子性 */
    public boolean unlock(String key, String value) {
        DefaultRedisScript<Long> script =
                new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class);
        Long result = redisTemplate.execute(script, Collections.singletonList(key), value);
        return result != null && result > 0;
    }
}

要点: 加锁时 value 用唯一值,解锁时用 Lua 脚本先判断 value 是否一致,再删除,防止误删别人的锁。


十、常见面试题 & 易错点#

10.1 Redis 为什么是单线程还这么快?#

  • 纯内存操作,无磁盘 IO
  • 单线程避免上下文切换和锁竞争
  • IO 多路复用(epoll)处理并发连接
  • 高效的数据结构(SDS、跳表、渐进式 rehash 等)

10.2 Redis 是单线程的吗?#

  • 命令执行是单线程的(6.0 前网络 IO 也是单线程)
  • Redis 6.0 后引入多线程网络 IO(只处理读写网络,命令执行仍是单线程)

10.3 Redis 和 MySQL 有什么区别?#

对比项RedisMySQL
存储位置内存磁盘
速度极快较慢(受磁盘和 SQL 影响)
数据类型灵活(5 种结构)表结构
持久化RDB/AOF默认持久化
适用缓存、高并发关系型数据、事务

10.4 缓存和数据库如何保证一致性?#

  • 先更新数据库,再删除缓存(推荐)
  • 缓存设置过期时间作为兜底
  • 高一致性场景用延迟双删
  • 最终一致即可,无需强一致

10.5 Redis 事务支持回滚吗?#

  • 不支持回滚。语法错误会导致事务整体不执行;运行时错误(如类型错误)其他命令仍会执行,失败命令不会回滚。
  • 需要原子性复杂逻辑用 Lua 脚本。

10.6 如何实现限流?#

计数器法:

# 1 秒内最多 100 次请求
INCR rate:user:1
EXPIRE rate:user:1 1   # 首次设置过期

配合 Java 判断返回值是否超过阈值。

10.7 Redis 大 key 有什么问题?#

  • 删除或读取时阻塞(单线程)
  • 网络带宽占用大
  • 内存分布不均(集群)
  • 建议: 拆分大 key、使用 UNLINK 异步删除、合理设置过期时间。

10.8 如何查找 bigkey?#

# 使用 redis-cli --bigkeys 扫描
redis-cli --bigkeys

# 使用 SCAN 遍历 + MEMORY USAGE 判断
MEMORY USAGE key

十一、知识总结#

  1. Redis 是基于内存的键值数据库,单线程命令执行 + IO 多路复用,性能极高。
  2. 五种基本数据类型: String、Hash、List、Set、ZSet,分别对应不同场景。
  3. 高级类型: Bitmap(签到)、HyperLogLog(UV)、GEO(地理位置)、Stream(消息流)。
  4. 持久化: RDB(快照、恢复快)与 AOF(日志、安全),推荐混合持久化。
  5. 过期策略: 惰性删除 + 定期删除;内存不足时按 maxmemory-policy 淘汰。
  6. 高可用: 主从复制 → 哨兵 → 集群,逐级增强。
  7. 缓存三大问题: 穿透(缓存空值/布隆过滤器)、击穿(互斥锁/逻辑过期)、雪崩(随机过期/高可用)。
  8. 分布式锁: SET key value NX PX + Lua 脚本释放,确保原子性和防止误删。
  9. 一致性: 先更新数据库再删缓存,过期时间兜底,追求最终一致。

学习建议:多动手在 redis-cli 中操作命令,结合 Spring Boot 项目中实际使用,并阅读源码理解底层数据结构(SDS、跳表、渐进式 rehash)。

页内目录11 章