Redis 基础

什么是 Redis

Redis（Remote Dictionary Server，远程字典服务器）是一个开源的基于内存的高性能键值对数据库。它由意大利开发者 Salvatore Sanfilippo（网名 antirez）于 2009 年开发，使用 ANSI C 语言编写。

Redis 的发展历程

2009 年：Redis 首次发布，最初是作为 LLOOGG（一个实时分析工具）的数据库
2010 年：支持主从复制
2011 年：支持虚拟内存（VM）特性（后续版本移除）
2012 年：发布 Redis 2.6，引入 Lua 脚本支持
2013 年：发布 Redis 2.8，增强主从复制功能
2015 年：发布 Redis 3.0，正式支持集群模式
2017 年：发布 Redis 4.0，提供模块系统和混合持久化
2018 年：发布 Redis 5.0，引入 Stream 数据类型
2020 年：发布 Redis 6.0，引入多线程 I/O、客户端缓存等新特性
2021 年：发布 Redis 7.0，进一步优化性能和功能

核心特点

基于内存存储：数据主要存储在内存中，读写速度极快（读 110000 次/s，写 81000 次/s）
键值对存储：采用 Key-Value 形式存储数据，支持丰富的数据结构
丰富的数据结构：支持 String、List、Set、Hash、ZSet、Bitmap、HyperLogLog、GEO、Stream 等多种数据结构
单线程模型：主要命令处理采用单线程，避免并发问题，简化实现（Redis 6.0 引入多线程 I/O）
持久化支持：提供 RDB（快照）和 AOF（日志）两种持久化方式，可混合使用
高可用：支持主从复制、哨兵（Sentinel）和集群（Cluster）模式
支持事务：提供 MULTI/EXEC/DISCARD/WATCH 等事务命令
发布订阅：内置消息发布订阅功能
Lua 脚本：支持 Lua 脚本执行复杂操作

Redis 与其他数据库对比

Redis vs Memcached

特性	Redis	Memcached
数据类型	支持多种数据结构	只支持简单的 Key-Value
持久化	支持	不支持
集群	支持原生集群	需要客户端或代理实现
线程模型	单线程（6.0 后多线程 I/O）	多线程
内存使用	更高效	相对较低
功能丰富度	功能丰富	功能简单

选择建议：

需要持久化、复杂数据结构：选择 Redis
纯缓存场景，追求极致简单：选择 Memcached

Redis vs MySQL

特性	Redis	MySQL
存储位置	内存	磁盘
数据结构	Key-Value，灵活	关系型，结构化
查询能力	简单 Key 查询	SQL 复杂查询
事务支持	简单事务	完整 ACID
适用场景	缓存、计数器、排行榜	业务数据存储

选择建议：

Redis 不是 MySQL 的替代品，而是补充
常见搭配：MySQL 作为主存储，Redis 作为缓存层

Redis 为什么这么快

1. 基于内存操作

内存访问速度是纳秒级，磁盘是毫秒级，相差 10 万倍。Redis 将所有数据加载到内存中，避免了磁盘 I/O。

2. 单线程模型

Redis 使用单线程处理命令，避免了：

线程上下文切换：线程切换需要保存和恢复寄存器、栈等信息
锁竞争：多线程需要加锁保护共享数据
多核缓存失效：多核 CPU 的缓存一致性协议开销

注意：单线程仅指命令处理线程，Redis 实际上还有：

后台持久化线程（BGSAVE、BGREWRITEAOF）
主从复制相关的线程
Redis 6.0 引入的多线程 I/O 处理网络请求

3. I/O 多路复用

Redis 使用 epoll（Linux）、kqueue（macOS/BSD）等 I/O 多路复用技术：

// 伪代码示例
while (true) {
    // epoll_wait 监听多个文件描述符
    events = epoll_wait(epfd, events, MAX_EVENTS, timeout);

    // 处理就绪的事件
    for (event in events) {
        if (event is readable) {
            read_and_parse_command();
            execute_command();
            send_response();
        }
    }
}

优势：单个线程可以高效处理成千上万的并发连接

4. 高效的数据结构

Redis 底层使用了优化的数据结构：

SDS（Simple Dynamic String）：比 C 字符串更高效、安全
跳表（Skip List）：ZSet 的底层实现，O(log N) 复杂度
压缩列表（ZipList）：小数据量时的紧凑存储
整数集合（IntSet）：纯整数数据的优化存储
快速列表（QuickList）：List 的底层实现，结合了链表和压缩列表

Redis 应用场景详解

1. 缓存系统

场景：缓存热点数据，减轻数据库压力

# 缓存用户信息
SET user:1001:profile '{"id":1001,"name":"张三","age":25}'
GET user:1001:profile

# 缓存文章内容
SET article:1001:content "文章内容..." EX 3600  # 1小时过期

缓存模式：

Cache-Aside（旁路缓存）：先查缓存，未命中再查数据库，然后写入缓存
Read-Through：应用程序只访问缓存，缓存负责从数据库加载
Write-Through：写缓存时同步写数据库
Write-Behind：先写缓存，异步写数据库（性能最高，可能丢数据）

2. 会话缓存（Session）

场景：分布式系统中存储用户 Session

# 用户登录后存储 Session
SET session:abc123 '{"userId":1001,"loginTime":"2024-01-01"}' EX 1800

# 验证 Session
GET session:abc123

# 用户登出删除 Session
DEL session:abc123

优势：

跨服务器共享 Session
自动过期，无需手动清理
性能高，减少数据库压力

3. 计数器

场景：文章点赞数、阅读数、视频播放量等

# 点赞
INCR article:1001:likes  # 返回新的点赞数

# 批量增加
INCRBY article:1001:views 100

# 浏览计数（可重复计数）
INCR article:1001:views

# 统计日活用户
SADD daily:active:20240101 "user:1001"
SCARD daily:active:20240101  # 返回活跃用户数

4. 排行榜

场景：游戏排名、热榜、积分榜等

# 添加分数
ZADD game:score 1000 "player1"
ZADD game:score 1200 "player2"
ZADD game:score 1150 "player3"

# 获取前 10 名（降序）
ZREVRANGE game:score 0 9 WITHSCORES

# 查看某个玩家的排名
ZREVRANK game:score "player2"

# 增加分数
ZINCRBY game:score 50 "player1"

# 获取指定分数范围的玩家
ZRANGEBYSCORE game:score 1000 1200 WITHSCORES

5. 消息队列

场景：异步任务处理、日志收集等

# List 实现队列（FIFO）
LPUSH queue:task "task1"           # 生产者
LPUSH queue:task "task2"
RPOP queue:task                    # 消费者

# List 实现栈（LIFO）
LPUSH stack:task "task1"
LPOP stack:task

# Stream 实现可靠消息队列（Redis 5.0+）
XADD stream:orders * user_id 1001 product_id 2001
XREAD STREAMS stream:orders $
XREAD GROUP group1 consumer1 STREAMS stream:orders 0
XACK stream:orders group1 <message-id>

6. 分布式锁

场景：防止并发操作冲突

# 获取锁（SETNX + 过期时间）
SET lock:order:1001 "uuid" NX EX 10

# 执行业务逻辑
# ...

# 释放锁（Lua 脚本保证原子性）
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

最佳实践：

使用 SET key value NX EX timeout 命令（2.6.12+）
设置过期时间，防止死锁
使用唯一值作为 Value，释放锁时验证
使用 Lua 脚本保证释放锁的原子性

7. 地理位置

场景：附近的人、地理位置服务

# 添加位置信息
GEOADD locations 116.404 39.915 "user1"
GEOADD locations 116.408 39.918 "user2"
GEOADD locations 116.410 39.920 "user3"

# 查找附近的用户（10km 内）
GEORADIUS locations 116.404 39.915 10 km

# 查看两个位置的距离
GEODIST locations user1 user2 km

# 获取位置信息
GEOPOS locations user1

# 获取位置 hash（geohash）
GEOHASH locations user1

8. 抽奖系统

场景：活动抽奖、随机选择

# 参与抽奖（Set 去重）
SADD lottery:participants "user1"
SADD lottery:participants "user2"

# 随机抽取 1 名中奖者
SRANDMEMBER lottery:participants

# 随机抽取 3 名中奖者（不删除）
SRANDMEMBER lottery:participants 3

# 随机抽取并移除
SPOP lottery:participants

9. 点赞/标签系统

场景：文章点赞、共同好友、标签管理

# 点赞（Set 去重）
SADD article:1001:liked "user:1001"
SADD article:1001:liked "user:1002"

# 取消点赞
SREM article:1001:liked "user:1001"

# 判断是否点赞
SISMEMBER article:1001:liked "user:1001"

# 获取点赞数
SCARD article:1001:liked

# 获取所有点赞用户
SMEMBERS article:1001:liked

# 共同好友（交集）
SINTER user:1001:friends user:1002:friends

10. 限流

场景：API 限流、防止刷接口

# 方式一：基于固定窗口
INCR api:limit:user:1001
EXPIRE api:limit:user:1001 60  # 第一次设置过期时间

# 方式二：基于令牌桶（更平滑）
# 每 10 秒恢复 1 个令牌，最大 10 个

Redis 安装与启动

Windows 安装

Redis 官方不支持 Windows，但可以使用第三方维护的版本：

# 下载 Windows 版本（非官方）
# https://github.com/tporadowski/redis/releases
# 或 https://github.com/microsoftarchive/redis/releases

# 解压后，启动服务器
redis-server.exe

# 指定配置文件启动
redis-server.exe redis.windows.conf

# 启动客户端（新开一个终端）
redis-cli.exe -h localhost -p 6379

# 如果设置了密码
redis-cli.exe -a your_password

注意：生产环境建议使用 Linux 或 Docker，Windows 版本更新较慢。

Linux 安装

Ubuntu/Debian

# 更新包列表
sudo apt-get update

# 安装 Redis
sudo apt-get install redis-server

# 启动 Redis 服务
sudo systemctl start redis-server

# 设置开机自启
sudo systemctl enable redis-server

# 查看运行状态
sudo systemctl status redis-server

# 测试连接
redis-cli ping

CentOS/RHEL

# 安装 EPEL 源
sudo yum install epel-release

# 安装 Redis
sudo yum install redis

# 启动 Redis
sudo systemctl start redis

# 设置开机自启
sudo systemctl enable redis

# 查看状态
sudo systemctl status redis

编译安装（推荐）

# 1. 下载源码
wget https://download.redis.io/redis-stable.tar.gz
tar xvzf redis-stable.tar.gz
cd redis-stable

# 2. 编译安装
make
make test
sudo make install

# 3. 配置 Redis
mkdir -p /etc/redis
cp redis.conf /etc/redis/redis.conf

# 4. 启动 Redis
redis-server /etc/redis/redis.conf

macOS 安装

# 使用 Homebrew 安装
brew install redis

# 启动 Redis 服务
brew services start redis

# 或者直接启动
redis-server

# 连接测试
redis-cli ping

Docker 安装（推荐）

# 拉取最新版镜像
docker pull redis:latest

# 拉取指定版本
docker pull redis:7.0

# 启动容器（简单启动）
docker run -d -p 6379:6379 --name redis redis:latest

# 启动容器（持久化数据）
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /data/redis/data:/data \
  -v /data/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  redis:latest \
  redis-server /usr/local/etc/redis/redis.conf

# 查看容器日志
docker logs -f redis

# 连接容器内的 Redis
docker exec -it redis redis-cli

# 停止容器
docker stop redis

# 启动已停止的容器
docker start redis

# 删除容器
docker rm redis

Docker Compose 方式

创建 docker-compose.yml：

version: '3.8'
services:
  redis:
    image: redis:7.0
    container_name: redis
    ports:
      - "6379:6379"
    volumes:
      - ./redis/data:/data
      - ./redis/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    restart: always

启动：

docker-compose up -d

Redis 基本命令详解

连接与认证

# 连接本地 Redis（默认 localhost:6379）
redis-cli

# 连接远程 Redis
redis-cli -h 192.168.1.100 -p 6379

# 连接并指定数据库（0-15）
redis-cli -n 1

# 密码认证（命令行）
redis-cli -a your_password

# 或连接后认证
redis-cli
AUTH your_password

# 测试连接
PING
# 返回: PONG

# 切换数据库
SELECT 1

# 查看当前数据库大小
DBSIZE

# 查看当前使用的数据库编号
ECHOoola

键操作命令

# ============ 基本操作 ============

# 设置键值
SET mykey "Hello Redis"

# 获取键值
GET mykey

# 设置多个键值
MSET key1 "value1" key2 "value2" key3 "value3"

# 获取多个键值
MGET key1 key2 key3

# 设置键值并指定过期时间（秒）
SET mykey "value" EX 60

# 设置键值并指定过期时间（毫秒）
SET mykey "value" PX 60000

# 设置键值（只在键不存在时）
SET mykey "value" NX

# 设置键值（只在键存在时）
SET mykey "value" XX

# ============ 过期时间 ============

# 设置过期时间（秒）
EXPIRE mykey 60

# 设置过期时间（毫秒）
PEXPIRE mykey 60000

# 查看剩余过期时间（秒）
TTL mykey
# 返回: -1（永不过期）、-2（已过期）、>0（剩余秒数）

# 查看剩余过期时间（毫秒）
PTTL mykey

# 删除过期时间
PERSIST mykey

# ============ 键管理 ============

# 删除键（可删除多个）
DEL key1 key2 key3

# 判断键是否存在（返回数量）
EXISTS mykey
EXISTS key1 key2 key3

# 查看键的类型
TYPE mykey
# 返回: string、list、set、hash、zset 等

# 重命名键
RENAME oldkey newkey

# 重命名键（仅当 newkey 不存在时）
RENAMENX oldkey newkey

# 随机返回一个键
RANDOMKEY

# 查找键（pattern 支持 *、?、[] 通配符）
# 注意：生产环境慎用，会阻塞
KEYS user:*
KEYS user:10??
KEYS user:[123]*

# 查询符合条件的键数量（不阻塞）
SCAN 0 MATCH user:* COUNT 100

# ============ 键遍历 ============

# 游标遍历（SCAN 命令不会阻塞）
SCAN 0
SCAN 0 MATCH user:* COUNT 10
SCAN cursor  # 使用上次的 cursor

# ============ 其他操作 ============

# 移动键到其他数据库
MOVE mykey 1

# 获取键的内存占用
MEMORY USAGE mykey

# 序列化给定键
DUMP mykey

# 反序列化并存储
RESTORE mykey 60 "serialized_value" REPLACE

服务器管理命令

# ============ 信息查看 ============

# 查看 Redis 服务器信息
INFO

# 查看特定部分信息
INFO server
INFO memory
INFO persistence
INFO replication
INFO stats

# 查看 Redis 版本
INFO server | grep redis_version

# ============ 客户端管理 ============

# 查看客户端连接列表
CLIENT LIST

# 查看连接的客户端数量
CLIENT GETNAME

# 设置客户端名称
CLIENT SETNAME "my_connection"

# 杀死客户端连接
CLIENT KILL ip:port

# 暂停客户端（毫秒）
CLIENT PAUSE 1000

# ============ 配置管理 ============

# 获取配置项
CONFIG GET requirepass
CONFIG GET "*"

# 设置配置项
CONFIG SET requirepass "new_password"
CONFIG SET loglevel "verbose"

# 重写配置文件
CONFIG REWRITE

# ============ 数据库管理 ============

# 清空当前数据库
FLUSHDB

# 清空所有数据库（危险！）
FLUSHALL

# 异步清空当前数据库
FLUSHDB ASYNC

# 异步清空所有数据库
FLUSHALL ASYNC

# ============ 监控与调试 ============

# 实时监控命令执行
MONITOR

# 慢查询日志
SLOWLOG GET 10      # 获取最近 10 条慢查询
SLOWLOG LEN         # 慢查询数量
SLOWLOG RESET       # 清空慢查询日志

# ============ 时间与统计 ============

# 查看最后一次保存时间
LASTSAVE

# 查看服务器时间
TIME

# ============ 持久化操作 ============

# 在后台保存 RDB
BGSAVE

# 立即保存 RDB（会阻塞）
SAVE

# 重写 AOF 文件
BGREWRITEAOF

# ============ 主从复制 ============

# 同步主从复制
SYNC

# ============ 性能测试 ============

# 测试命令执行时间
# 先执行：redis-cli latency

数据操作命令（预览）

# ============ String ============
SET key value
GET key
INCR key
DECR key
INCRBY key increment
APPEND key value
STRLEN key

# ============ Hash ============
HSET key field value
HGET key field
HMSET key field1 value1 field2 value2
HMGET key field1 field2
HGETALL key
HDEL key field
HEXISTS key field

# ============ List ============
LPUSH key value
RPUSH key value
LPOP key
RPOP key
LRANGE key 0 -1
LLEN key

# ============ Set ============
SADD key member
SMEMBERS key
SISMEMBER key member
SCARD key
SREM key member

# ============ ZSet ============
ZADD key score member
ZRANGE key 0 -1
ZREVRANGE key 0 -1 WITHSCORES
ZRANK key member
ZREM key member

Redis 配置文件详解

Redis 配置文件 redis.conf 包含数百个配置项，以下是最重要的配置说明：

网络配置

# 绑定地址（默认只监听本地）
# 生产环境建议绑定内网 IP 或 0.0.0.0
bind 127.0.0.1
bind 192.168.1.100

# 监听端口
port 6379

# TCP 监听队列长度（backlog）
tcp-backlog 511

# 客户端空闲多少秒后关闭连接（0 表示禁用）
timeout 0

# TCP keepalive
tcp-keepalive 300

# 是否使用保护模式（防止公网访问）
protected-mode yes

通用配置

# 是否以守护进程方式运行
daemonize no

# PID 文件路径
pidfile /var/run/redis_6379.pid

# 日志级别：debug、verbose、notice、warning
loglevel notice

# 日志文件路径
logfile "/var/log/redis/redis.log"

# 数据库数量
databases 16

# 是否显示 Logo
always-show-logo yes

安全配置

# 访问密码
requirepass your_strong_password

# 重命名危险命令（禁用命令）
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command CONFIG "CONFIG_b840fc02d524045429941cc15f59e41cb2be2364"

# 限制客户端可执行的最大命令数
# 0 表示无限制
maxclients 10000

内存管理

# 最大内存限制（0 表示不限制）
# 建议设置为物理内存的 50%-70%
maxmemory 2gb

# 内存淘汰策略
# volatile-lru: 从已设置过期时间的键中驱逐最少使用的
# allkeys-lru: 从所有键中驱逐最少使用的（推荐）
# volatile-lfu: 从已设置过期时间的键中驱逐使用频率最低的
# allkeys-lfu: 从所有键中驱逐使用频率最低的
# volatile-random: 随机驱逐已设置过期时间的键
# allkeys-random: 随机驱逐任意键
# volatile-ttl: 驱逐即将过期的键
# noeviction: 不驱逐，返回错误（默认）
maxmemory-policy allkeys-lru

# 内存碎片整理
activedefrag yes
active-defrag-ignore-bytes 100mb
active-defrag-threshold-lower 10
active-defrag-threshold-upper 100

RDB 持久化配置

# RDB 快照文件名
dbfilename dump.rdb

# RDB 文件存放目录
dir /var/lib/redis

# 保存策略（格式：save <seconds> <changes>）
save 900 1      # 900 秒内至少 1 个 key 变化
save 300 10     # 300 秒内至少 10 个 key 变化
save 60 10000   # 60 秒内至少 10000 个 key 变化

# 禁用 RDB（注释掉所有 save 或使用 save ""）
# save ""

# 持久化出错后是否继续工作
stop-writes-on-bgsave-error yes

# 是否压缩 RDB 文件
rdbcompression yes

# RDB 文件是否校验
rdbchecksum yes

AOF 持久化配置

# 是否开启 AOF
appendonly yes

# AOF 文件名
appendfilename "appendonly.aof"

# AOF 同步策略
# always: 每次写入都同步（最安全，最慢）
# everysec: 每秒同步一次（推荐，折中）
# no: 由操作系统决定（最快，可能丢数据）
appendfsync everysec

# AOF 重写时是否同步
no-appendfsync-on-rewrite no

# AOF 自动重写触发条件
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# AOF 文件损坏时加载截断的文件
aof-load-truncated yes

# AOF 和 RDB 混合持久化（Redis 4.0+）
aof-use-rdb-preamble yes

主从复制配置

# 从库配置
replicaof <masterip> <masterport>

# 主库密码（如果主库设置了密码）
masterauth <master-password>

# 从库只读
replica-serve-stale-data yes
replica-read-only yes

# 重连接延迟
repl-diskless-sync no
repl-diskless-sync-delay 5

性能优化

# 最大内存（之前已介绍）
maxmemory 2gb

# 是否使用哈希表优化
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

# List 最大压缩列表大小
list-max-ziplist-size -2

# Set 最大整数集合大小
set-max-intset-entries 512

# ZSet 最大压缩列表大小
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# HyperLogLog
hll-sparse-max-bytes 3000

# 网络缓冲区大小
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60

Redis 客户端工具

命令行客户端

# 基本使用
redis-cli

# 常用参数
-h          # 指定主机
-p          # 指定端口
-a          # 指定密码
-n          # 指定数据库编号
-u          # 使用 Redis URI 连接
--scan      # 扫描键
--latency   # 延迟监控
--stat      # 实时统计
--bigkeys   # 查找大键
--memkeys   # 查找内存占用大的键
--hotkeys   # 查找热键（需要开启 maxmemory-policy）

# 示例
redis-cli -h 192.168.1.100 -p 6379 -a password -n 1
redis-cli --bigkeys
redis-cli --stat

图形化客户端工具

1. RedisInsight（官方推荐）

特点：

官方免费工具
功能强大，界面友好
支持多平台

下载：https://redis.com/redis-enterprise/redis-insight/

2. Another Redis Desktop Manager

特点：

开源免费
轻量级，响应快
支持 Windows、Mac、Linux

GitHub：https://github.com/qishibo/AnotherRedisDesktopManager

3. Redis Commander

特点：

Web 界面
Node.js 实现

安装：

npm install -g redis-commander
redis-commander

编程语言客户端

Java

<!-- Jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version>
</dependency>

<!-- Lettuce（Spring Data Redis 默认） -->
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.2.1.RELEASE</version>
</dependency>

Python

pip install redis

import redis

r = redis.Redis(host='localhost', port=6379, db=0, password='password')
r.set('key', 'value')
print(r.get('key'))

Go

go get -u github.com/go-redis/redis/v8

Node.js

npm install redis

Redis 数据类型总览

数据类型	底层实现	时间复杂度	典型应用场景
String	SDS、int、embstr	O(1)	缓存、计数器、分布式锁、Session
Hash	ZipList、HashTable	O(1)	对象存储、购物车、用户信息
List	QuickList、LinkedList	O(1) 两端	消息队列、时间线、最新列表
Set	IntSet、HashTable	O(1)	标签、共同好友、抽奖、去重
ZSet	ZipList、SkipList+HashTable	O(log N)	排行榜、优先级队列、打分系统
Bitmap	String（按位）	O(1)	签到、在线用户、布隆过滤器
HyperLogLog	String（基数统计）	O(1)	UV 统计、去重计数
GEO	ZSet（编码经纬度）	O(log N)	附近的人、地理位置服务
Stream	RadixTree+List	O(1)	消息队列、事件溯源

Redis 性能测试

redis-benchmark 工具

# 基本测试（10 万次请求）
redis-benchmark -n 100000

# 测试特定命令
redis-benchmark -t set,get,lpush,lpop -n 100000

# 测试并显示详细输出
redis-benchmark -n 100000 -q

# 测试 50 个并发连接
redis-benchmark -n 100000 -c 50

# 使用 pipeline
redis-benchmark -n 100000 -P 16

# 测试大数据
redis-benchmark -n 100000 -d 32768

# 使用自定义脚本
redis-benchmark -n 100000 script load "redis.call('set','key','value')"

性能测试示例

# 综合测试（100 个并发，10 万次请求）
redis-benchmark -h 192.168.1.100 -p 6379 -a password -c 100 -n 100000

# 输出示例：
# SET: 98765 次请求/秒
# GET: 99123 次请求/秒
# LPUSH: 97561 次请求/秒
# ...

Redis 监控与调试

实时监控

# 实时查看执行的命令（开发环境使用）
redis-cli MONITOR

# 查看慢查询
redis-cli SLOWLOG GET 10

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

# 设置慢查询阈值（微秒）
redis-cli CONFIG SET slowlog-log-slower-than 10000

常用监控命令

# 查看连接数
redis-cli INFO clients

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

# 查看命中率
redis-cli INFO stats | grep keyspace

# 查看命令统计
redis-cli INFO commandstats

# 查看持久化状态
redis-cli INFO persistence

Redis 最佳实践

1. 键命名规范

# 使用冒号分隔命名空间
user:1001:profile
user:1001:session
article:1001:content
article:1001:likes

# 缓存键
cache:user:1001
cache:article:1001

# 锁键
lock:order:1001
lock:payment:20240101

# 限流键
limit:api:user:1001:2024010110

2. 合理设置过期时间

# 热点数据缓存
SET hot:article:1001 "content" EX 600    # 10 分钟

# Session 存储
SET session:uuid "data" EX 1800          # 30 分钟

# 临时验证码
SET verify:code:13800138000 "1234" EX 300  # 5 分钟

# 限流计数器
SET limit:api:user:1001 "10" EX 60       # 1 分钟

3. 避免大 Key

# ❌ 不推荐：大字符串
SET huge_data "10MB 的数据..."

# ✅ 推荐：拆分存储
SET huge_data:part1 "数据1"
SET huge_data:part2 "数据数据2"

# ❌ 不推荐：大列表（百万级元素）
LPUSH huge_list item1 item2 ...

# ✅ 推荐：分批处理或使用其他数据结构

4. 使用连接池

// Java (Jedis)
JedisPool pool = new JedisPool("localhost", 6379);
try (Jedis jedis = pool.getResource()) {
    jedis.set("key", "value");
}

// Python
pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
r = redis.Redis(connection_pool=pool)

5. 批量操作

# ❌ 不推荐：多次网络往返
GET key1
GET key2
GET key3

# ✅ 推荐：一次网络往返
MGET key1 key2 key3

# ✅ 推荐：使用 Pipeline
redis-cli --pipe < commands.txt

6. 选择合适的数据结构

# 存储对象
# ❌ String JSON 序列化
SET user:1001 '{"name":"张三","age":25}'

# ✅ Hash
HSET user:1001 name "张三"
HSET user:1001 age 25

# 列表去重
# ❌ List
LPUSH list user1 user2 user1

# ✅ Set
SADD set user1 user2 user1

7. 设置内存淘汰策略

# 推荐：LRU 策略
maxmemory-policy allkeys-lru

# 或：LFU 策略（更适合高频访问场景）
maxmemory-policy allkeys-lfu

8. 监控和告警

# 定期检查内存使用
redis-cli INFO memory | grep used_memory_human

# 检查慢查询
redis-cli SLOWLOG GET 10

# 检查连接数
redis-cli INFO clients | grep connected_clients

9. 备份和恢复

# 定期备份 RDB 文件
cp /var/lib/redis/dump.rdb /backup/dump_$(date +%Y%m%d).rdb

# 测试备份恢复
redis-cli --test-memory 1

10. 安全加固

# 设置强密码
requirepass "C0mplex!Pass@word"

# 禁用危险命令
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command CONFIG ""
rename-command SHUTDOWN ""

# 绑定内网 IP
bind 192.168.1.100

# 启用保护模式
protected-mode yes

Redis 常见问题与故障排查

1. 连接失败

# 检查 Redis 是否启动
redis-cli ping

# 检查端口是否监听
netstat -an | grep 6379

# 检查防火墙
sudo ufw status

# 检查 bind 配置
redis-cli CONFIG GET bind

2. 内存不足

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

# 查看最大的键
redis-cli --bigkeys

# 设置内存淘汰策略
redis-cli CONFIG SET maxmemory-policy allkeys-lru

3. 慢查询

# 查看慢查询日志
redis-cli SLOWLOG GET 10

# 检查是否使用了 O(N) 命令
# KEYS、SMEMBERS、HGETALL 等

# 使用 SCAN 替代 KEYS
SCAN 0 MATCH user:* COUNT 100

4. 主从同步问题

# 查看复制状态
redis-cli INFO replication

# 在从库检查同步延迟
redis-cli -h slave_ip INFO replication | grep master_link_down_since_seconds

小结

本节全面介绍了 Redis 的基础知识，包括：

Redis 概述：发展历程、核心特点、与其他数据库对比
高性能原理：内存存储、单线程模型、I/O 多路复用、高效数据结构
应用场景详解：10+ 种典型应用场景及代码示例
安装与部署：Windows、Linux、macOS、Docker 多种安装方式
基本命令：连接认证、键操作、服务器管理等命令详解
配置文件：网络、安全、内存、持久化等配置说明
客户端工具：命令行、图形化工具、编程语言客户端
数据类型预览：9 种数据类型及应用场景
性能测试：redis-benchmark 使用方法
监控调试：实时监控、慢查询、性能分析
最佳实践：键命名、过期时间、连接池、批量操作等
常见问题：故障排查与解决方案

掌握这些基础知识后，下一节我们将深入学习 Redis 的各种数据结构及其具体应用。

什么是 Redis​

Redis 的发展历程​

核心特点​

Redis 与其他数据库对比​

Redis vs Memcached​

Redis vs MySQL​

Redis 为什么这么快​

1. 基于内存操作​

2. 单线程模型​

3. I/O 多路复用​

4. 高效的数据结构​

Redis 应用场景详解​

1. 缓存系统​

2. 会话缓存（Session）​

3. 计数器​

4. 排行榜​

5. 消息队列​

6. 分布式锁​

7. 地理位置​

8. 抽奖系统​

9. 点赞/标签系统​

10. 限流​

Redis 安装与启动​

Windows 安装​

Linux 安装​

Ubuntu/Debian​

CentOS/RHEL​

编译安装（推荐）​

macOS 安装​

Docker 安装（推荐）​

Docker Compose 方式​

Redis 基本命令详解​

连接与认证​

键操作命令​

服务器管理命令​

数据操作命令（预览）​

Redis 配置文件详解​

网络配置​

通用配置​

安全配置​

内存管理​

RDB 持久化配置​

AOF 持久化配置​

主从复制配置​

性能优化​

Redis 客户端工具​

命令行客户端​

图形化客户端工具​

1. RedisInsight（官方推荐）​

2. Another Redis Desktop Manager​

3. Redis Commander​

编程语言客户端​

Java​

Python​

Go​

Node.js​

Redis 数据类型总览​

Redis 性能测试​

redis-benchmark 工具​

性能测试示例​

Redis 监控与调试​

实时监控​

常用监控命令​

Redis 最佳实践​

1. 键命名规范​

2. 合理设置过期时间​

3. 避免大 Key​

4. 使用连接池​

5. 批量操作​

6. 选择合适的数据结构​

7. 设置内存淘汰策略​

8. 监控和告警​

9. 备份和恢复​

10. 安全加固​

Redis 常见问题与故障排查​

1. 连接失败​

2. 内存不足​

3. 慢查询​

4. 主从同步问题​

小结​