Redis简介与核心概念

1. 什么是Redis？

基本定义

Redis（Remote Dictionary Server）是一个开源的、基于内存的数据结构存储系统，可以用作：

• 数据库：持久化存储数据
• 缓存：提高数据访问速度
• 消息中间件：支持发布订阅模式
• 队列：实现任务队列和延迟队列

为什么选择Redis？

1. 性能极高：基于内存操作，读写速度可达10万+ QPS
2. 数据结构丰富：支持字符串、哈希、列表、集合、有序集合等
3. 原子性操作：所有操作都是原子性的，支持事务
4. 持久化：支持RDB和AOF两种持久化方式
5. 主从复制：支持主从复制，提高可用性
6. 集群模式：支持分片集群，实现水平扩展

Redis vs 其他数据库

特性	Redis	MySQL	MongoDB
存储方式	内存+磁盘	磁盘	磁盘
性能	极高	中等	中等
数据结构	丰富	关系型	文档型
持久化	支持	支持	支持
适用场景	缓存、会话、计数器	事务、复杂查询	文档存储、分析

2. Redis核心架构

单线程模型

Redis采用单线程模型，主要基于以下考虑：

1. **避免锁竞争**：单线程避免了多线程间的锁竞争和上下文切换
2. **内存操作**：Redis主要操作内存，CPU不是瓶颈
3. **网络I/O**：使用epoll多路复用，高效处理网络请求
4. **原子性**：所有操作天然原子性，无需额外同步

工作流程：
客户端请求 → 事件循环 → 命令执行 → 响应返回

内存管理

Redis内存管理策略：

1. **内存分配器**：使用jemalloc或tcmalloc，避免内存碎片
2. **过期策略**：
   - 惰性删除：访问时检查过期
   - 定期删除：随机采样检查过期
3. **内存淘汰**：
   - LRU：最近最少使用
   - LFU：最不经常使用
   - Random：随机淘汰

持久化机制详解

1. 什么是持久化？

持久化的概念

持久化是指将Redis内存中的数据保存到磁盘上，确保数据在Redis重启后不会丢失。

为什么需要持久化？

1. 数据安全：防止Redis崩溃导致数据丢失
2. 数据恢复：Redis重启后可以恢复之前的数据
3. 数据备份：可以将数据备份到其他位置
4. 灾难恢复：在服务器故障后可以恢复数据

2. RDB持久化（快照）

RDB是什么？

RDB（Redis Database）是Redis的默认持久化方式，它会在指定的时间间隔内将内存中的数据集快照写入磁盘。

RDB工作原理

RDB持久化过程：

1. **触发条件**：
   - 手动执行SAVE或BGSAVE命令
   - 配置文件中的save配置项
   - 主从复制时，从节点接收RDB文件

2. **执行过程**：
   - SAVE：阻塞主进程，直到RDB文件创建完成
   - BGSAVE：fork子进程，子进程负责创建RDB文件

3. **文件格式**：
   - 二进制格式，紧凑高效
   - 包含数据、过期时间、类型信息等

RDB配置示例

# redis.conf
# 900秒内如果至少有1个key被修改，则执行save
save 900 1
# 300秒内如果至少有10个key被修改，则执行save
save 300 10
# 60秒内如果至少有10000个key被修改，则执行save
save 60 10000

# RDB文件名称
dbfilename dump.rdb
# RDB文件保存路径
dir /var/lib/redis
# 是否压缩RDB文件
rdbcompression yes
# 是否校验RDB文件
rdbchecksum yes

RDB优缺点分析

优点：

• 文件紧凑，适合备份和传输
• 恢复速度快，适合大数据量恢复
• 对Redis性能影响小

缺点：

• 可能丢失最后一次快照后的数据
• 不适合频繁写入的场景
• 大数据量时fork子进程可能阻塞

3. AOF持久化（追加文件）

AOF是什么？

AOF（Append Only File）以日志的形式记录Redis的每一个写操作，只追加不修改文件。

AOF工作原理

AOF持久化过程：

1. **命令记录**：
   - 每个写命令都会追加到AOF文件末尾
   - 包括SET、DEL、EXPIRE等操作

2. **文件重写**：
   - 当AOF文件过大时，会进行重写
   - 重写过程会fork子进程，不影响主进程
   - 重写后的文件只包含重建数据的最小命令集

3. **同步策略**：
   - always：每次写操作都同步到磁盘
   - everysec：每秒同步一次（默认）
   - no：由操作系统决定何时同步

AOF配置示例

# redis.conf
# 开启AOF持久化
appendonly yes
# AOF文件名称
appendfilename "appendonly.aof"
# AOF同步策略
appendfsync everysec
# AOF重写时是否同步
no-appendfsync-on-rewrite no
# AOF文件大小超过上次重写时的100%时重写
auto-aof-rewrite-percentage 100
# AOF文件大小超过64MB时重写
auto-aof-rewrite-min-size 64mb

AOF优缺点分析

优点：

• 数据安全性高，最多丢失1秒的数据
• 文件可读性好，便于分析和修复
• 支持多种同步策略

缺点：

• 文件体积大，恢复速度慢
• 对Redis性能有一定影响
• 需要定期重写以控制文件大小

4. 混合持久化

什么是混合持久化？

Redis 4.0引入了混合持久化，结合了RDB和AOF的优点。

混合持久化原理

混合持久化过程：

1. **RDB部分**：文件开头是RDB格式的数据
2. **AOF部分**：RDB数据后面是AOF格式的增量数据
3. **重写过程**：
   - 先写入RDB数据
   - 再写入AOF增量数据
   - 最终生成一个文件

4. **恢复过程**：
   - 先加载RDB数据
   - 再重放AOF增量数据

混合持久化配置

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

混合持久化优势

1. 恢复速度快：RDB部分恢复快
2. 数据安全：AOF部分保证数据完整性
3. 文件紧凑：比纯AOF文件小
4. 兼容性好：向下兼容RDB和AOF

主从复制与哨兵模式

1. 主从复制详解

什么是主从复制？

主从复制是指将一台Redis服务器的数据复制到其他Redis服务器，前者称为主节点（Master），后者称为从节点（Slave）。

为什么需要主从复制？

1. 数据备份：从节点作为主节点的数据备份
2. 读写分离：主节点负责写，从节点负责读
3. 负载均衡：分散读请求，提高系统整体性能
4. 故障恢复：主节点故障时，从节点可以提升为主节点

主从复制原理

主从复制过程：

1. **建立连接**：
   - 从节点向主节点发送PING命令
   - 主节点回复PONG命令
   - 建立TCP连接

2. **身份验证**：
   - 如果设置了密码，从节点发送AUTH命令
   - 主节点验证密码

3. **数据同步**：
   - 全量同步：从节点接收RDB文件
   - 增量同步：接收主节点的写命令

4. **命令传播**：
   - 主节点执行写命令后，将命令发送给从节点
   - 从节点执行相同的命令

主从复制配置

# 主节点配置（redis.conf）
# 设置密码
requirepass master123
# 开启AOF持久化
appendonly yes

# 从节点配置（redis.conf）
# 设置主节点地址和端口
slaveof 192.168.1.100 6379
# 设置主节点密码
masterauth master123
# 设置从节点密码
requirepass slave123
# 设置从节点只读
slave-read-only yes

主从复制命令

# 查看复制信息
redis-cli info replication

# 手动设置主从关系
redis-cli slaveof 192.168.1.100 6379

# 取消主从关系
redis-cli slaveof no one

# 查看从节点状态
redis-cli info slaves

2. 哨兵模式详解

什么是哨兵模式？

哨兵模式是Redis的高可用解决方案，通过哨兵节点监控主从节点的状态，自动进行故障转移。

为什么需要哨兵模式？

1. 自动故障检测：自动检测主节点是否故障
2. 自动故障转移：主节点故障时自动选择新的主节点
3. 配置更新：自动更新客户端的主节点地址
4. 监控告警：提供监控和告警功能

哨兵工作原理

哨兵工作流程：

1. **监控**：
   - 哨兵每秒向主从节点发送PING命令
   - 检查节点是否响应
   - 检查主从复制状态

2. **主观下线**：
   - 单个哨兵认为节点不可达
   - 设置节点为sdown状态

3. **客观下线**：
   - 多个哨兵认为节点不可达
   - 设置节点为odown状态

4. **故障转移**：
   - 选择新的主节点
   - 更新其他从节点的主节点
   - 通知客户端新的主节点地址

哨兵配置示例

# sentinel.conf
# 监控主节点mymaster，2个哨兵认为下线才客观下线
sentinel monitor mymaster 192.168.1.100 6379 2
# 主观下线时间30秒
sentinel down-after-milliseconds mymaster 30000
# 故障转移超时时间180秒
sentinel failover-timeout mymaster 180000
# 并行同步从节点数量1
sentinel parallel-syncs mymaster 1
# 设置主节点密码
sentinel auth-pass mymaster master123

哨兵启动命令

# 启动哨兵
redis-sentinel sentinel.conf

# 或者使用redis-server启动
redis-server sentinel.conf --sentinel

# 查看哨兵信息
redis-cli -p 26379 info sentinel

集群模式详解

1. 什么是Redis集群？

集群概念

Redis集群是Redis的分布式解决方案，通过分片（Sharding）将数据分散到多个节点上，实现数据的水平扩展。

为什么需要集群？

1. 数据量大：单机Redis无法存储大量数据
2. 性能瓶颈：单机Redis无法承受高并发
3. 可用性要求：需要更高的可用性
4. 扩展性需求：需要动态扩展节点

集群架构

Redis集群架构：

1. **节点类型**：
   - 主节点：负责数据存储和读写
   - 从节点：负责数据备份和故障转移

2. **分片策略**：
   - 使用CRC16算法计算key的hash值
   - 对16384取模，确定key属于哪个槽位
   - 每个槽位分配给一个主节点

3. **数据分布**：
   - 16384个槽位均匀分布到主节点
   - 每个主节点负责一部分槽位
   - 支持槽位迁移和重新分片

2. 集群配置与部署

集群配置文件

# redis-7000.conf
port 7000
cluster-enabled yes
cluster-config-file nodes-7000.conf
cluster-node-timeout 15000
appendonly yes

集群创建命令

# 启动6个Redis节点
redis-server redis-7000.conf
redis-server redis-7001.conf
redis-server redis-7002.conf
redis-server redis-7003.conf
redis-server redis-7004.conf
redis-server redis-7005.conf

# 创建集群（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

# 查看集群信息
redis-cli -p 7000 cluster info

# 查看节点信息
redis-cli -p 7000 cluster nodes

集群操作命令

# 添加主节点
redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000

# 添加从节点
redis-cli --cluster add-node 127.0.0.1:7007 127.0.0.1:7000 --cluster-slave --cluster-master-id <master-id>

# 删除节点
redis-cli --cluster del-node 127.0.0.1:7000 <node-id>

# 重新分片
redis-cli --cluster reshard 127.0.0.1:7000

3. 集群特性与限制

集群特性

1. 自动分片：数据自动分布到不同节点
2. 故障转移：主节点故障时自动切换
3. 槽位迁移：支持动态调整数据分布
4. 批量操作：支持批量操作，但key必须在同一槽位

集群限制

1. 多键操作：不支持跨槽位的多键操作
2. 事务支持：不支持跨槽位的事务
3. Lua脚本：Lua脚本中的key必须在同一槽位
4. 数据库选择：不支持SELECT命令

Lua脚本详解

1. 什么是Lua脚本？

Lua脚本概念

Lua是一种轻量级的脚本语言，Redis内置了Lua解释器，支持在Redis中执行Lua脚本。

为什么使用Lua脚本？

1. 原子性：整个脚本作为一个原子操作执行
2. 性能优化：减少网络往返，提高性能
3. 复杂逻辑：支持复杂的业务逻辑
4. 减少锁竞争：避免分布式锁的使用

Lua脚本优势

Lua脚本 vs 多次Redis命令：

1. **网络开销**：
   - 多次命令：多次网络往返
   - Lua脚本：一次网络往返

2. **原子性**：
   - 多次命令：无法保证原子性
   - Lua脚本：天然原子性

3. **性能**：
   - 多次命令：需要多次解析命令
   - Lua脚本：一次解析，多次执行

4. **一致性**：
   - 多次命令：可能出现数据不一致
   - Lua脚本：保证数据一致性

2. Lua脚本语法与使用

基本语法

-- 获取参数
local key = KEYS[1]
local value = ARGV[1]

-- 执行Redis命令
redis.call('SET', key, value)
local result = redis.call('GET', key)

-- 返回结果
return result

脚本执行方式

# 方式1：直接执行脚本
redis-cli --eval script.lua key1 key2 , arg1 arg2

# 方式2：先加载脚本，再执行
redis-cli script load "$(cat script.lua)"
redis-cli evalsha <sha1> 2 key1 key2 arg1 arg2

# 方式3：在Redis中执行
redis-cli eval "return redis.call('GET', KEYS[1])" 1 mykey

实际应用示例

示例1：原子性计数器

-- atomic_counter.lua
local key = KEYS[1]
local increment = tonumber(ARGV[1])

-- 获取当前值
local current = redis.call('GET', key)
if current == false then
    current = 0
else
    current = tonumber(current)
end

-- 增加计数
local new_value = current + increment

-- 设置新值
redis.call('SET', key, new_value)

-- 返回新值
return new_value

示例2：分布式锁

-- distributed_lock.lua
local lock_key = KEYS[1]
local lock_value = ARGV[1]
local expire_time = tonumber(ARGV[2])

-- 尝试获取锁
local result = redis.call('SET', lock_key, lock_value, 'NX', 'EX', expire_time)

if result then
    return 1  -- 获取锁成功
else
    return 0  -- 获取锁失败
end

示例3：限流器

-- rate_limiter.lua
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])

-- 获取当前时间
local current_time = redis.call('TIME')[1]

-- 清理过期的记录
redis.call('ZREMRANGEBYSCORE', key, 0, current_time - window)

-- 获取当前窗口内的请求数
local count = redis.call('ZCARD', key)

if count < limit then
    -- 添加当前请求
    redis.call('ZADD', key, current_time, current_time)
    redis.call('EXPIRE', key, window)
    return 1  -- 允许请求
else
    return 0  -- 拒绝请求
end

3. Lua脚本最佳实践

性能优化

1. 减少网络往返：尽量在一个脚本中完成所有操作
2. 避免大循环：避免在脚本中执行大循环
3. 合理使用KEYS：KEYS数组用于指定操作的键
4. 参数传递：使用ARGV数组传递参数

错误处理

-- 错误处理示例
local function safe_call(cmd, ...)
    local status, result = pcall(redis.call, cmd, ...)
    if not status then
        -- 记录错误日志
        redis.log(redis.LOG_WARNING, "Redis command failed: " .. tostring(result))
        return nil
    end
    return result
end

-- 使用安全调用
local value = safe_call('GET', key)
if value then
    -- 处理结果
else
    -- 处理错误
end

调试技巧

-- 调试脚本
local function debug_log(message)
    redis.log(redis.LOG_WARNING, "DEBUG: " .. tostring(message))
end

-- 在脚本中添加调试信息
debug_log("Processing key: " .. tostring(KEYS[1]))
debug_log("Value: " .. tostring(ARGV[1]))

事务与管道

1. Redis事务详解

什么是Redis事务？

Redis事务是一组命令的集合，这些命令要么全部执行，要么全部不执行。

为什么需要事务？

1. 原子性：保证操作的原子性
2. 一致性：保证数据的一致性
3. 隔离性：事务之间相互隔离
4. 持久性：事务执行后数据持久化

事务特性

Redis事务特点：

1. **不支持回滚**：Redis事务不支持回滚操作
2. **乐观锁**：使用WATCH命令实现乐观锁
3. **批量执行**：使用MULTI/EXEC命令批量执行
4. **原子性**：事务内的命令要么全部执行，要么全部不执行

事务命令

# 开始事务
MULTI

# 执行命令（不会立即执行）
SET key1 value1
SET key2 value2
INCR counter

# 执行事务
EXEC

# 取消事务
DISCARD

# 监视键的变化
WATCH key1 key2

# 取消监视
UNWATCH

事务示例

# 示例1：基本事务
redis-cli
> MULTI
> SET user:1:name "Alice"
> SET user:1:age 25
> EXEC

# 示例2：使用WATCH实现乐观锁
redis-cli
> WATCH balance
> MULTI
> DECRBY balance 100
> EXEC

2. Redis管道详解

什么是Redis管道？

Redis管道（Pipeline）是一种批量执行命令的机制，可以一次性发送多个命令，减少网络往返次数。

为什么使用管道？

1. 减少网络延迟：批量发送命令，减少网络往返
2. 提高吞吐量：显著提高Redis的吞吐量
3. 原子性：管道中的命令不是原子性的
4. 性能优化：适合批量操作的场景

管道使用示例

# 使用redis-cli的管道功能
echo -e "SET key1 value1\nSET key2 value2\nGET key1" | redis-cli --pipe

# 使用redis-cli的批量模式
redis-cli --eval - <<EOF
local results = {}
for i = 1, 100 do
    table.insert(results, redis.call('SET', 'key' .. i, 'value' .. i))
end
return results
EOF

管道性能对比

性能对比：

1. **不使用管道**：
   - 100个SET命令：100次网络往返
   - 总时间：100 * 网络延迟

2. **使用管道**：
   - 100个SET命令：1次网络往返
   - 总时间：1 * 网络延迟

3. **性能提升**：
   - 理论上可以提升100倍性能
   - 实际提升取决于网络延迟和命令复杂度

3. 事务与管道的选择

使用场景对比

特性	事务	管道
原子性	支持	不支持
性能	较低	较高
网络往返	多次	一次
适用场景	需要原子性	批量操作

选择建议

1. 需要原子性：选择事务
2. 批量操作：选择管道
3. 性能要求高：选择管道
4. 数据一致性要求高：选择事务

发布订阅模式

1. 什么是发布订阅？

发布订阅概念

发布订阅（Pub/Sub）是一种消息通信模式，发布者（Publisher）发送消息到频道（Channel），订阅者（Subscriber）接收频道中的消息。

为什么使用发布订阅？

1. 解耦：发布者和订阅者之间解耦
2. 广播：支持一对多的消息广播
3. 实时性：消息实时传递
4. 扩展性：支持动态添加订阅者

发布订阅模式

发布订阅流程：

1. **订阅**：客户端订阅一个或多个频道
2. **发布**：发布者向频道发送消息
3. **接收**：订阅者接收频道中的消息
4. **取消订阅**：客户端取消订阅频道

频道类型：
- 普通频道：直接订阅
- 模式频道：使用通配符订阅

2. 发布订阅命令

基本命令

# 订阅频道
SUBSCRIBE channel1 channel2

# 模式订阅
PSUBSCRIBE user.*

# 发布消息
PUBLISH channel1 "Hello World"

# 取消订阅
UNSUBSCRIBE channel1

# 取消模式订阅
PUNSUBSCRIBE user.*

# 查看订阅信息
PUBSUB CHANNELS
PUBSUB NUMSUB channel1
PUBSUB NUMPAT

实际应用示例

示例1：聊天室

# 用户A订阅聊天室
redis-cli
> SUBSCRIBE chat:room1

# 用户B发布消息
redis-cli
> PUBLISH chat:room1 "Hello everyone!"

# 用户A会收到消息
1) "message"
2) "chat:room1"
3) "Hello everyone!"

示例2：系统通知

# 订阅系统通知
redis-cli
> PSUBSCRIBE system:*

# 发布系统通知
redis-cli
> PUBLISH system:maintenance "System will be down for maintenance"
> PUBLISH system:update "System update completed"

3. 发布订阅的优缺点

优点

1. 解耦：发布者和订阅者完全解耦
2. 实时性：消息实时传递
3. 扩展性：支持动态添加订阅者
4. 简单性：使用简单，易于理解

缺点

1. 可靠性：消息可能丢失
2. 持久性：消息不持久化
3. 顺序性：不保证消息顺序
4. 回溯性：无法回溯历史消息

使用建议

1. 实时通知：适合实时通知场景
2. 日志收集：适合日志收集和监控
3. 事件驱动：适合事件驱动的架构
4. 消息队列：不适合需要可靠性的消息队列

性能优化与监控

1. Redis性能优化

内存优化

内存优化策略：

1. **合理设置过期时间**：
   - 为数据设置合适的过期时间
   - 避免内存无限增长

2. **使用合适的数据结构**：
   - 字符串：简单键值对
   - 哈希：对象属性
   - 列表：队列、栈
   - 集合：去重、交集
   - 有序集合：排行榜、范围查询

3. **压缩存储**：
   - 启用压缩功能
   - 使用合适的数据类型

网络优化

网络优化策略：

1. **使用管道**：批量执行命令
2. **使用Lua脚本**：减少网络往返
3. **连接池**：复用连接
4. **批量操作**：使用MSET、MGET等批量命令

配置优化

# redis.conf 性能优化配置
# 内存策略
maxmemory-policy allkeys-lru

# 持久化配置
save ""
appendonly no

# 网络配置
tcp-keepalive 300
tcp-backlog 511

# 客户端配置
timeout 0
tcp-keepalive 300

2. Redis监控

监控指标

# 查看Redis信息
redis-cli info

# 查看内存使用
redis-cli info memory

# 查看连接信息
redis-cli info clients

# 查看命令统计
redis-cli info stats

# 查看复制信息
redis-cli info replication

# 查看集群信息
redis-cli info cluster

性能测试

# 使用redis-benchmark进行性能测试
redis-benchmark -h 127.0.0.1 -p 6379 -n 100000 -c 50

# 测试特定命令
redis-benchmark -h 127.0.0.1 -p 6379 -n 100000 -c 50 -t set,get

# 测试管道性能
redis-benchmark -h 127.0.0.1 -p 6379 -n 100000 -c 50 -P 16

监控工具

1. Redis Commander：Web界面管理工具
2. Redis Desktop Manager：桌面客户端
3. RedisInsight：Redis官方管理工具
4. Prometheus + Grafana：监控和可视化

实际应用场景

1. 缓存系统

缓存架构

缓存架构设计：

1. **多级缓存**：
   - L1：本地缓存（Caffeine）
   - L2：Redis缓存
   - L3：数据库

2. **缓存策略**：
   - 缓存穿透：布隆过滤器
   - 缓存击穿：分布式锁
   - 缓存雪崩：随机过期时间

3. **数据一致性**：
   - 先更新数据库，再删除缓存
   - 延迟双删策略
   - 消息队列异步更新

缓存实现示例

@Service
public class UserCacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private UserService userService;
    
    public User getUserById(Long id) {
        String key = "user:" + id;
        
        // 1. 查询缓存
        User user = (User) redisTemplate.opsForValue().get(key);
        if (user != null) {
            return user;
        }
        
        // 2. 查询数据库
        user = userService.getById(id);
        if (user != null) {
            // 3. 更新缓存
            redisTemplate.opsForValue().set(key, user, 1, TimeUnit.HOURS);
        }
        
        return user;
    }
    
    public void updateUser(User user) {
        // 1. 更新数据库
        userService.updateUser(user);
        
        // 2. 删除缓存
        String key = "user:" + user.getId();
        redisTemplate.delete(key);
    }
}

2. 分布式锁

锁实现原理

分布式锁设计：

1. **基本要求**：
   - 互斥性：同一时间只有一个客户端能持有锁
   - 防死锁：锁必须能自动释放
   - 高性能：获取和释放锁的性能要高

2. **实现方式**：
   - SET NX EX：原子性设置键值
   - Lua脚本：保证操作的原子性
   - 看门狗机制：自动续期

3. **注意事项**：
   - 锁的粒度要合适
   - 超时时间要合理
   - 要考虑锁的重入性

分布式锁实现

@Service
public class DistributedLockService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    private static final String LOCK_SCRIPT = 
        "if redis.call('set', KEYS[1], ARGV[1], 'NX', 'EX', ARGV[2]) then " +
        "return 1 " +
        "else " +
        "return 0 " +
        "end";
    
    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 boolean tryLock(String key, String value, long expireSeconds) {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
        script.setScriptText(LOCK_SCRIPT);
        script.setResultType(Long.class);
        
        Long result = redisTemplate.execute(script, 
            Collections.singletonList(key), value, String.valueOf(expireSeconds));
        
        return Long.valueOf(1).equals(result);
    }
    
    public boolean releaseLock(String key, String value) {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
        script.setScriptText(UNLOCK_SCRIPT);
        script.setResultType(Long.class);
        
        Long result = redisTemplate.execute(script, 
            Collections.singletonList(key), value);
        
        return Long.valueOf(1).equals(result);
    }
}

3. 消息队列

队列实现原理

消息队列设计：

1. **基本结构**：
   - 使用List实现队列
   - LPUSH/RPUSH：入队
   - LPOP/RPOP：出队
   - BLPOP/BRPOP：阻塞出队

2. **高级特性**：
   - 优先级队列：使用有序集合
   - 延迟队列：使用有序集合+时间戳
   - 死信队列：处理失败的消息

3. **可靠性保证**：
   - 消息持久化
   - 消息确认机制
   - 重试机制

消息队列实现

@Service
public class MessageQueueService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    private static final String QUEUE_KEY = "message:queue";
    private static final String DELAY_QUEUE_KEY = "message:delay:queue";
    
    // 发送消息
    public void sendMessage(String message) {
        redisTemplate.opsForList().rightPush(QUEUE_KEY, message);
    }
    
    // 接收消息
    public String receiveMessage() {
        return redisTemplate.opsForList().leftPop(QUEUE_KEY, 30, TimeUnit.SECONDS);
    }
    
    // 发送延迟消息
    public void sendDelayMessage(String message, long delaySeconds) {
        long executeTime = System.currentTimeMillis() / 1000 + delaySeconds;
        redisTemplate.opsForZSet().add(DELAY_QUEUE_KEY, message, executeTime);
    }
    
    // 处理延迟消息
    @Scheduled(fixedRate = 1000)
    public void processDelayMessage() {
        long currentTime = System.currentTimeMillis() / 1000;
        Set<String> messages = redisTemplate.opsForZSet()
            .rangeByScore(DELAY_QUEUE_KEY, 0, currentTime);
        
        for (String message : messages) {
            // 处理消息
            processMessage(message);
            // 从延迟队列中移除
            redisTemplate.opsForZSet().remove(DELAY_QUEUE_KEY, message);
        }
    }
    
    private void processMessage(String message) {
        // 消息处理逻辑
        System.out.println("Processing message: " + message);
    }
}

4. 会话管理

会话存储

@Service
public class SessionService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String SESSION_PREFIX = "session:";
    private static final int SESSION_EXPIRE = 3600; // 1小时
    
    // 创建会话
    public String createSession(User user) {
        String sessionId = UUID.randomUUID().toString();
        String key = SESSION_PREFIX + sessionId;
        
        // 存储会话信息
        redisTemplate.opsForValue().set(key, user, SESSION_EXPIRE, TimeUnit.SECONDS);
        
        return sessionId;
    }
    
    // 获取会话
    public User getSession(String sessionId) {
        String key = SESSION_PREFIX + sessionId;
        return (User) redisTemplate.opsForValue().get(key);
    }
    
    // 更新会话
    public void updateSession(String sessionId, User user) {
        String key = SESSION_PREFIX + sessionId;
        redisTemplate.opsForValue().set(key, user, SESSION_EXPIRE, TimeUnit.SECONDS);
    }
    
    // 删除会话
    public void deleteSession(String sessionId) {
        String key = SESSION_PREFIX + sessionId;
        redisTemplate.delete(key);
    }
    
    // 延长会话过期时间
    public void extendSession(String sessionId) {
        String key = SESSION_PREFIX + sessionId;
        redisTemplate.expire(key, SESSION_EXPIRE, TimeUnit.SECONDS);
    }
}

总结

1. Redis核心特性总结

持久化机制

• RDB：适合备份和恢复，性能影响小
• AOF：数据安全性高，适合频繁写入
• 混合持久化：结合两者优点，推荐使用

高可用方案

• 主从复制：数据备份和读写分离
• 哨兵模式：自动故障检测和转移
• 集群模式：水平扩展和高可用

高级功能

• Lua脚本：原子性操作和复杂逻辑
• 事务：保证操作的原子性
• 管道：提高批量操作性能
• 发布订阅：消息广播和解耦

2. 最佳实践建议

性能优化

1. 合理使用数据结构：根据业务场景选择合适的数据结构
2. 使用管道和Lua脚本：减少网络往返，提高性能
3. 设置合理的过期时间：避免内存无限增长
4. 监控和调优：定期监控性能指标，及时调优

可靠性保证

1. 持久化配置：根据业务需求选择合适的持久化策略
2. 高可用部署：使用哨兵或集群模式提高可用性
3. 数据备份：定期备份数据，防止数据丢失
4. 监控告警：建立完善的监控和告警机制

安全性考虑

1. 访问控制：设置强密码，限制访问IP
2. 网络隔离：使用内网部署，避免公网暴露
3. 数据加密：敏感数据加密存储
4. 审计日志：记录操作日志，便于审计

3. 学习建议

理论学习

1. 理解原理：深入理解Redis的设计原理和实现机制
2. 阅读源码：阅读Redis源码，理解内部实现
3. 官方文档：仔细阅读Redis官方文档和最佳实践

实践应用

1. 搭建环境：搭建Redis单机、主从、哨兵、集群环境
2. 编写代码：使用Redis实现各种业务场景
3. 性能测试：进行性能测试，优化配置参数
4. 问题排查：学会排查和解决Redis相关问题

持续学习

1. 关注更新：关注Redis版本更新和新特性
2. 社区参与：参与Redis社区讨论和贡献
3. 技术分享：分享学习心得和技术经验
4. 项目实践：在实际项目中应用Redis技术

记住：**Redis是一个功能强大、性能优异的缓存和存储系统，掌握Redis的高级特性能够帮助你构建高性能、高可用的应用系统。通过理论学习、实践应用和持续学习，你一定能够成为Redis技术专家！ **