小新博客

主题

siushin2026-02-24
5590
25.9m

Redis命令 ​

清空数据库数据 ​

  • FLUSHDB 清空当前数据库
  • FLUSHALL 清空所有数据库
  • DEL 删除键值对（针对单个或多个键）

字符串String ​

  • SET key value 设置键值对
  • GET key 获取键值对
  • DEL key 删除键值对
  • EXPIRE key seconds 设置键值对的过期时间
  • TTL key 查看键值对的剩余过期时间
  • INCR key 对键值对进行自增操作
  • INCRBY key increment 对键值对进行自增操作，并指定步长
  • INCRBYFLOAT key increment 对键值对进行自增操作，并指定步长，支持浮点数
  • DECR key 对键值对进行自减操作
  • DECRBY key decrement 对键值对进行自减操作，并指定步长
  • APPEND key value 在键值对的末尾追加值
  • STRLEN key 获取键值对的长度
  • MSET key1 value1 key2 value2 ... 同时设置多个键值对
  • MGET key1 key2 ... 同时获取多个键值对
  • MSETNX key1 value1 key2 value2 ... 同时设置多个键值对，如果键已经存在则不进行设置
  • GETSET key value 设置键值对，并返回旧值
  • SETRANGE key offset value 从指定位置开始设置键值对的值
  • GETRANGE key start end 获取键值对的指定范围的值
  • SETEX key seconds value 设置键值对，并指定过期时间

哈希Hash ​

  • HSET key field value 设置哈希表的字段值
  • HGET key field 获取哈希表的字段值
  • HDEL key field1 field2 ... 删除哈希表的字段
  • HLEN key 获取哈希表的字段数量
  • HEXISTS key field 判断哈希表是否存在指定字段
  • HKEYS key 获取哈希表的所有字段
  • HVALS key 获取哈希表的所有值
  • HGETALL key 获取哈希表的所有字段和值
  • HINCRBY key field increment 对哈希表的字段值进行自增操作
  • HINCRBYFLOAT key field increment 对哈希表的字段值进行自增操作，并指定步长，支持浮点数
  • HMSET key field1 value1 field2 value2 ... 同时设置哈希表的多个字段值
  • HMGET key field1 field2 ... 同时获取哈希表的多个字段值
  • HSETNX key field value 设置哈希表的字段值，如果字段已经存在则不进行设置
  • HSTRLEN key field 获取哈希表的字段值的长度

列表List ​

  1. ArrayList使用数组方式
  2. LinkedList使用双向链表方式
  3. 双向链表中增加数据
  4. 双向链表中删除数据

📌 核心使用场景 ​

RPopLPush/BRPopLPush 的核心价值是原子性地从源列表右侧弹出并压入目标列表，常用于可靠队列、循环任务、延迟 / 重试处理等场景，解决普通 RPOP 易丢消息、消费状态难维护的问题。

  • 可靠消息队列（生产消费）

生产者 LPUSH 入队；消费者用 BRPopLPush（阻塞版）原子获取并移入 “处理中” 列表。处理完成用 LREM 移除；失败 / 超时则将 “处理中” 元素移回待处理队列，防消息丢失。

例：订单创建后发通知、日志收集、异步任务调度。

  • 延迟 / 重试任务（死信 / 重试队列）

先入待处理队列；消费失败时，将元素移入重试 / 死信列表，按超时或优先级重新处理。

例：支付回调失败重试、第三方接口调用失败兜底。

  • 循环任务 / 环形队列（负载均衡）

源列表与目标列表同名，实现环形流转；多消费者竞争取任务，天然负载均衡。

例：多 worker 并发处理任务，避免单节点过载。

  • 批量处理与进度追踪

临时将批量元素移入 “处理中” 列表，分批执行；完成后批量清理，便于监控进度与失败恢复。

例：批量数据清洗、报表生成、用户批量操作。

常用命令 ​

  • LPUSH key value1 value2 ... 将一个或多个值插入到列表的头部
  • RPUSH key value1 value2 ... 将一个或多个值插入到列表的尾部
  • LPOP key 移除并返回列表的第一个元素
  • RPOP key 移除并返回列表的最后一个元素
  • LPUSHX key value 将一个值插入到列表的头部，如果列表不存在则不进行插入
  • LINDEX key index 获取列表指定索引的元素
  • LLEN key 获取列表的长度
  • LRANGE key start stop 获取列表指定范围的元素
  • LREM key count value 移除列表中指定数量的值
  • LSET key index value 设置列表指定索引的元素
  • LTRIM key start stop 修剪列表，只保留指定范围的元素
  • LINSERT key BEFORE|AFTER pivot value 在列表中插入值，指定插入位置为指定值的前面或后面
  • RPOPLPUSH source destination 移除列表的最后一个元素，并将该元素插入到另一个列表的头部
  • BLPOP key1 key2 ... timeout 从列表的头部移除并返回第一个非空列表的第一个元素，如果所有列表都为空，则等待指定的时间
  • BRPOP key1 key2 ... timeout 从列表的尾部移除并返回第一个非空列表的最后一个元素，如果所有列表都为空，则等待指定的时间

两端添加 ​

redis
127.0.0.1:6379> lpush mylist a b c
(integer) 3
127.0.0.1:6379> lpush mylist 1 2 3
(integer) 6
127.0.0.1:6379> rpush mylist2 a b c
(integer) 3
127.0.0.1:6379> rpush mylist2 1 2 3
(integer) 6
127.0.0.1:6379> lrange mylist 0 5
1) "3"
2) "2"
3) "1"
4) "c"
5) "b"
6) "a"
127.0.0.1:6379> lrange mylist2 0 -1
1) "a"
2) "b"
3) "c"
4) "1"
5) "2"
6) "3"
127.0.0.1:6379> lrange mylist2 0 -2
1) "a"
2) "b"
3) "c"
4) "1"
5) "2"
127.0.0.1:6379> lpushx mylist x
(integer) 6
127.0.0.1:6379> lrange mylist 0 -1
1) "x"
2) "2"
3) "1"
4) "c"
5) "b"
6) "a"
127.0.0.1:6379> lpushx mylist3 x
(integer) 0
127.0.0.1:6379> rpushx mylist2 y
(integer) 6
127.0.0.1:6379> lrange mylist2 0 -1
1) "a"
2) "b"
3) "c"
4) "1"
5) "2"
6) "y"

两端弹出 ​

redis
127.0.0.1:6379> lrange mylist 0 -1
1) "3"
2) "2"
3) "1"
4) "c"
5) "b"
6) "a"
127.0.0.1:6379> lpop mylist
"3"
127.0.0.1:6379> lrange mylist 0 -1
1) "2"
2) "1"
3) "c"
4) "b"
5) "a"
127.0.0.1:6379> lrange mylist2 0 -1
1) "a"
2) "b"
3) "c"
4) "1"
5) "2"
6) "3"
127.0.0.1:6379> rpop mylist2
"3"
127.0.0.1:6379> lrange mylist2 0 -1
1) "a"
2) "b"
3) "c"
4) "1"
5) "2"

获取列表元素个数 ​

redis
127.0.0.1:6379> llen mylist
(integer) 5
127.0.0.1:6379> llen mylist2
(integer) 5
127.0.0.1:6379> llen mylist3
(integer) 0

删除指定元素 ​

redis
127.0.0.1:6379> lpush mylist3 1 2 3
(integer) 3
127.0.0.1:6379> lpush mylist3 1 2 3
(integer) 6
127.0.0.1:6379> lpush mylist3 1 2 3
(integer) 9
127.0.0.1:6379> lrange mylist3 0 -1
1) "3"
2) "2"
3) "1"
4) "3"
5) "2"
6) "1"
7) "3"
8) "2"
9) "1"
127.0.0.1:6379> lrem mylist3 2 3
(integer) 2
127.0.0.1:6379> lrange mylist3 0 -1
1) "2"
2) "1"
3) "2"
4) "1"
5) "3"
6) "2"
7) "1"
127.0.0.1:6379> lrem mylist3 -2 1
(integer) 2
127.0.0.1:6379> lrange mylist3 0 -1
1) "2"
2) "1"
3) "2"
4) "3"
5) "2"
127.0.0.1:6379> lrem mylist3 0 2
(integer) 3
127.0.0.1:6379> lrange mylist3 0 -1
1) "1"
2) "3"

设置列表指定索引的元素 ​

redis
127.0.0.1:6379> lset mylist 3 mmm
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "x"
2) "2"
3) "1"
4) "mmm"
5) "b"
6) "a"

指定插入位置为指定值的前面或后面插入值 ​

redis
127.0.0.1:6379> lpush mylist4 a b c
(integer) 3
127.0.0.1:6379> lpush mylist4 a b c
(integer) 6
127.0.0.1:6379> lrange mylist4 0 -1
1) "c"
2) "b"
3) "a"
4) "c"
5) "b"
6) "a"
127.0.0.1:6379> linsert mylist4 before b 11
(integer) 7
127.0.0.1:6379> lrange mylist4 0 -1
1) "c"
2) "11"
3) "b"
4) "a"
5) "c"
6) "b"
7) "a"
127.0.0.1:6379> linsert mylist4 after b 22
(integer) 8
127.0.0.1:6379> lrange mylist4 0 -1
1) "c"
2) "11"
3) "b"
4) "22"
5) "a"
6) "c"
7) "b"
8) "a"

移除列表的最后一个元素，并将该元素插入到另一个列表的头部 ​

redis
127.0.0.1:6379> lpush mylist5 1 2 3
(integer) 3
127.0.0.1:6379> lpush mylist6 a b c
(integer) 3
127.0.0.1:6379> lrange mylist5 0 -1
1) "3"
2) "2"
3) "1"
127.0.0.1:6379> lrange mylist6 0 -1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> rpoplpush mylist5 mylist6
"1"
127.0.0.1:6379> lrange mylist5 0 -1
1) "3"
2) "2"
127.0.0.1:6379> lrange mylist6 0 -1
1) "1"
2) "c"
3) "b"
4) "a"

集合Set ​

和List类型不同的是，Set集合中不允许出现重复的元素。

Set可包括的最大元素数量是 4294967295。

集合可以用于存储一组不重复的元素，例如用户标签、商品分类等。

集合的底层实现是哈希表，因此它支持快速的插入、删除和查找操作。

常用命令 ​

  • SADD key member1 [member2 ...] 向集合中添加一个或多个元素
  • SREM key member1 [member2 ...] 从集合中移除一个或多个元素
  • SMEMBERS key 获取集合中的所有元素
  • SISMEMBER key member 判断元素是否在集合中
  • SCARD key 获取集合中元素的数量
  • SPOP key [count] 随机移除并返回集合中的一个或多个元素
  • SRANDMEMBER key [count] 随机返回集合中的一个或多个元素
  • SINTER key1 [key2 ...] 返回多个集合的交集
  • SUNION key1 [key2 ...] 返回多个集合的并集
  • SDIFF key1 [key2 ...] 返回多个集合的差集
  • SINTERSTORE destination key1 [key2 ...] 将多个集合的交集存储到 destination 集合中
  • SUNIONSTORE destination key1 [key2 ...] 将多个集合的并集存储到 destination 集合中
  • SDIFFSTORE destination key1 [key2 ...] 将多个集合的差集存储到 destination 集合中

添加元素 ​

redis
127.0.0.1:6379> sadd myset a b c
(integer) 3
127.0.0.1:6379> sadd myset a
(integer) 0
127.0.0.1:6379> srem myset b c
(integer) 2
127.0.0.1:6379> smembers myset
1) "a"

判断元素是否在集合中 ​

redis
127.0.0.1:6379> sismember myset a
(integer) 1
127.0.0.1:6379> sismember myset x
(integer) 0

获取集合中差集元素 ​

redis
127.0.0.1:6379> sadd mya1 a b c
(integer) 3
127.0.0.1:6379> sadd myb1 a c 1 2
(integer) 4
127.0.0.1:6379> sdiff mya1 myb1
1) "b"

获取集合中交集元素 ​

redis
127.0.0.1:6379> sadd mya2 a b c
(integer) 3
127.0.0.1:6379> sadd myb2 a c 1 2
(integer) 4
127.0.0.1:6379> sinter mya2 myb2
1) "a"
2) "c"

获取集合中并集元素 ​

redis
127.0.0.1:6379> sadd mya3 a b c
(integer) 3
127.0.0.1:6379> sadd myb3 a c 1 2
(integer) 4
127.0.0.1:6379> sunion mya3 myb3
1) "c"
2) "a"
3) "1"
4) "b"
5) "2"

获取集合中元素个数 ​

redis
127.0.0.1:6379> scard myb3
(integer) 4

随机返回集合中的一个或多个元素 ​

redis
127.0.0.1:6379> srandmember myb3
"1"
127.0.0.1:6379> srandmember myb3
"2"
127.0.0.1:6379> srandmember myb3
"a"
127.0.0.1:6379> srandmember myb3 2
1) "1"
2) "2"
127.0.0.1:6379> srandmember myb3 2
1) "c"
2) "2"

将多个集合的差集存储到 destination 集合中 ​

redis
127.0.0.1:6379> sdiffstore my1 mya1 myb1
(integer) 1
127.0.0.1:6379> smembers my1
1) "b"

将多个集合的交集存储到 destination 集合中 ​

redis
127.0.0.1:6379> sinter mya2 myb2
1) "a"
2) "c"
127.0.0.1:6379> sinterstore my2 mya2 myb2
(integer) 2
127.0.0.1:6379> smembers my2
1) "a"
2) "c"

将多个集合的并集存储到 destination 集合中 ​

redis
127.0.0.1:6379> sunion mya3 myb3
1) "c"
2) "a"
3) "1"
4) "b"
5) "2"
127.0.0.1:6379> sunionstore my3 mya3 myb3
(integer) 5
127.0.0.1:6379> smembers my3
1) "a"
2) "b"
3) "c"
4) "1"
5) "2"

有序集合Sorted Set/ZSet ​

有序集合和集合一样也是string类型元素的集合，且不允许重复的成员。

不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

有序集合的成员是唯一的，但分数(score)却可以重复。

有序集合的底层实现由跳跃表和哈希表组成。

📌 核心使用场景 ​

  • 排行榜（如大型在线游戏积分排行榜）
  • 带权重的投票系统
  • 地理位置系统
  • 带权重的随机元素选择
  • 带权重的分数排名
  • 构建索引数据

常用命令 ​

  • ZADD key score1 member1 [score2 member2 ...] 向有序集合中添加一个或多个成员，或者更新已存在成员的分数
  • ZREM key member [member ...] 从有序集合中移除一个或多个成员
  • ZCARD key 获取有序集合中成员的数量
  • ZCOUNT key min max 获取有序集合中指定分数范围内的成员数量
  • ZRANGE key start stop [WITHSCORES] 获取有序集合中指定索引范围内的成员
  • ZREVRANGE key start stop [WITHSCORES] 获取有序集合中指定索引范围内的成员，按分数从高到低排序
  • ZINCRBY key increment member 增加有序集合中指定成员的分数
  • ZPOPMAX key [count] 移除并返回有序集合中分数最大的元素
  • ZPOPMIN key [count] 移除并返回有序集合中分数最小的元素
  • ZRANGEBYSCORE key min max [WITHSCORES] 获取有序集合中指定分数范围内的成员
  • ZRANK key member 获取有序集合中指定成员的排名（从低到高）
  • ZREMRANGEBYRANK key start stop 移除有序集合中指定索引范围内的成员
  • ZREMRANGEBYSCORE key min max 移除有序集合中指定分数范围内的成员
  • ZREVRANGEBYSCORE key max min [WITHSCORES] 获取有序集合中指定分数范围内的成员，按分数从高到低排序
  • ZREVRANK key member 获取有序集合中指定成员的排名（从高到低）
  • ZSCAN key cursor [MATCH pattern] [COUNT count] 迭代有序集合中的元素
  • ZSCORE key member 获取有序集合中指定成员的分数
  • ZDIFF key1 [key2 ...] 计算给定的一个或多个有序集合的差集
  • ZDIFFSTORE destination numkeys key [key ...] 计算给定的一个或多个有序集合的差集，并将结果存储在 destination 中
  • ZINTER key1 [key2 ...] 计算给定的一个或多个有序集合的交集
  • ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] 计算给定的一个或多个有序集合的交集，并将结果存储在 destination 中
  • ZLEXCOUNT key min max 获取有序集合中指定字典范围内的成员数量
  • ZRANGEBYLEX key min max [LIMIT offset count] 获取有序集合中指定字典范围内的成员
  • ZREMRANGEBYLEX key min max 移除有序集合中指定字典范围内的成员
  • ZREVRANGEBYLEX key max min [LIMIT offset count] 获取有序集合中指定字典范围内的成员，按字典序从高到低排序
  • ZUNION key1 [key2 ...] 计算给定的一个或多个有序集合的并集
  • ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] 计算给定的一个或多个有序集合的并集，并将结果存储在 destination 中

添加元素 ​

redis
127.0.0.1:6379> zadd mysort 70 zs 80 ls 90 ww
(integer) 3
127.0.0.1:6379> zadd mysort 100 zs
(integer) 0
127.0.0.1:6379> zadd mysort 60 tom
(integer) 1

获得元素 ​

redis
127.0.0.1:6379> zscore mysort zs
"100"

获取元素个数 ​

redis
127.0.0.1:6379> zcard mysort
(integer) 4

删除元素 ​

redis
127.0.0.1:6379> zrem mysort tom ww
(integer) 2
127.0.0.1:6379> zcard mysort
(integer) 2

获取指定索引范围内的元素(从小到大) ​

redis
127.0.0.1:6379> zadd mysort 85 jack 95 rose
(integer) 2
127.0.0.1:6379> zrange mysort 0 -1
1) "ls"
2) "jack"
3) "rose"
4) "zs"
127.0.0.1:6379> zrange mysort 0 -1 withscores
1) "ls"
2) "80"
3) "jack"
4) "85"
5) "rose"
6) "95"
7) "zs"
8) "100"

获取指定索引范围内的元素(从大到小) ​

redis
127.0.0.1:6379> zrevrange mysort 0 -1 withscores
1) "zs"
2) "100"
3) "rose"
4) "95"
5) "jack"
6) "85"
7) "ls"
8) "80"

移除有序集合中指定索引范围内的成员 ​

redis
127.0.0.1:6379> zremrangebyrank mysort 0 4
(integer) 4
127.0.0.1:6379> zrange mysort 0 -1
(empty array)

移除有序集合中指定分数范围内的成员 ​

redis
127.0.0.1:6379> zadd mysort 80 zs 90 ls 100 ws
(integer) 3
127.0.0.1:6379> zremrangebyscore mysort 80 100
(integer) 3
127.0.0.1:6379> zrange mysort 0 -1
(empty array)

获取有序集合中指定分数范围内的成员 ​

redis
127.0.0.1:6379> zadd mysort 70 zs 80 ls 90 ws
(integer) 3
127.0.0.1:6379> zrangebyscore mysort 0 100
1) "zs"
2) "ls"
3) "ws"
127.0.0.1:6379> zrangebyscore mysort 0 100 withscores
1) "zs"
2) "70"
3) "ls"
4) "80"
5) "ws"
6) "90"
127.0.0.1:6379> zrangebyscore mysort 0 100 withscores limit 0 2
1) "zs"
2) "70"
3) "ls"
4) "80"

增加有序集合中指定成员的分数 ​

redis
127.0.0.1:6379> zincrby mysort 3 ls
"83"
127.0.0.1:6379> zscore mysort ls
"83"

获取有序集合中指定分数范围内的成员数量 ​

redis
127.0.0.1:6379> zcount mysort 80 90
(integer) 2

超级日志记录HyperLogLog（扩展数据类型） ​

统计二值状态Bitmap（扩展数据类型） ​

地理位置GEO（扩展数据类型） ​

Keys的通用操作 ​

  • KEYS pattern 查找所有符合给定模式 pattern 的 key（如：keys *）

获取所有key ​

redis
127.0.0.1:6379> keys num
1) "num"
127.0.0.1:6379> keys *
 1) "myhash"
 2) "mylist6"
 3) "myb3"
 4) "myb2"
 5) "mya2"
 6) "mylist3"
 7) "num2"
 8) "company"
 9) "mylist5"
10) "my2"
11) "mylist4"
12) "mya3"
13) "mylist2"
14) "num"
15) "myset"
16) "my3"
17) "num5"
18) "num3"
19) "my1"
20) "myb1"
21) "mysort"
22) "mylist"
23) "mya1"
127.0.0.1:6379> keys num*
1) "num2"
2) "num"
3) "num5"
4) "num3"
127.0.0.1:6379> keys num?
1) "num2"
2) "num5"
3) "num3"

删除key ​

redis
127.0.0.1:6379> del my1 my2 my3
(integer) 3

检查key是否存在 ​

redis
127.0.0.1:6379> exists my1
(integer) 0
127.0.0.1:6379> exists mya1
(integer) 1

重命名key ​

redis
127.0.0.1:6379> rename company newcompany
OK
127.0.0.1:6379> get company
(nil)
127.0.0.1:6379> get newcompany
"tony"

设置key的过期时间 ​

redis
127.0.0.1:6379> expire newcompany 1000
(integer) 1

获取key的过期时间 ​

redis
127.0.0.1:6379> ttl newcompany
(integer) 984
127.0.0.1:6379> ttl mya1
(integer) -1

获取key的类型 ​

redis
127.0.0.1:6379> type mystring
string
127.0.0.1:6379> type myhash
hash
127.0.0.1:6379> type mylist
list
127.0.0.1:6379> type myset
set
127.0.0.1:6379> type mysort
zset

特性：多数据库 ​

  • SELECT index 切换到指定的数据库（Redis默认有16个数据库，编号从0开始，默认使用第0个数据库）
  • MOVE key db 将当前数据库中的 key 移动到指定的数据库 db 中
  • FLUSHDB 清空当前数据库
  • FLUSHALL 清空所有数据库

切换数据库 ​

redis
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
(empty array)
127.0.0.1:6379[1]> select 0
OK
127.0.0.1:6379> keys *
 1) "myhash"
 2) "mylist6"
 3) "myb3"
 4) "myb2"
 5) "mya2"
 6) "mylist3"
 7) "num2"
 8) "mylist5"
 9) "mylist4"
10) "mya3"
11) "mylist2"
12) "num"
13) "myset"
14) "newcompany"
15) "num5"
16) "num3"
17) "myb1"
18) "mysort"
19) "mylist"
20) "mya1"

移动key到指定数据库 ​

redis
127.0.0.1:6379> move myset 1
(integer) 1
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
1) "myset"
127.0.0.1:6379[1]> type myset
set

特性：Redis事务 ​

  • MULTI 标记一个事务块的开始
  • EXEC 执行所有事务块内的命令
  • DISCARD 取消事务，放弃执行事务块内的所有命令
  • WATCH key [key ...] 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断
  • UNWATCH 取消 WATCH 命令对所有 key 的监视

提交事物 ​

  • 终端1
redis
127.0.0.1:6379> set num 1
OK
127.0.0.1:6379> get num
"1"
127.0.0.1:6379> get num
"2"
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incr num
QUEUED
127.0.0.1:6379(TX)> incr num
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 3
2) (integer) 4
  • 终端2
redis
127.0.0.1:6379> incr num
(integer) 2
127.0.0.1:6379> get num
"2"
127.0.0.1:6379> get num
"2"
127.0.0.1:6379> get num
"4"

回滚事物 ​

redis
127.0.0.1:6379> set user tom
OK
127.0.0.1:6379> get user
"tom"
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set user jerry
QUEUED
127.0.0.1:6379(TX)> discard
OK
127.0.0.1:6379> get user
"tom"

主从复制命令 ​

查看主从复制信息 ​

redis
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:0
master_failover_state:no-failover
master_replid:50fa0544bd0d7e18cce1082e6fbb92340225e30d
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:3
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

配置主从复制 ​

1. 实时执行（临时生效，重启后失效） ​

直接在 Redis 客户端执行以下命令，即可将当前从库指向目标主库：

redis
# 格式：replicaof 主库IP 主库端口
replicaof 192.168.1.100 6379

  • 示例：如果主库 IP 是 10.0.0.5，端口 6379，执行 replicaof 10.0.0.5 6379 即可。

  • 取消主从关系：执行 replicaof no one，当前实例会变回主库，不再同步原主库数据。

2. 配置文件设置（永久生效，推荐） ​

如果希望重启 Redis 后主从配置不丢失，需要修改从库的 redis.conf 配置文件：

redis
# 找到以下配置项，取消注释并修改为主库的 IP 和端口
replicaof 192.168.1.100 6379

# 可选：如果主库设置了密码，需要配置认证（否则同步失败）
masterauth 你的主库密码

# 可选：主从断开后自动重连（默认开启，建议保留）
replica-priority 100
replica-read-only yes  # 从库设为只读，避免误写

Redis持久化 ​

方式1：快照（RDB）方式持久化 ​

配置：自动触发持久化 ​

redis
save 900 1
save 300 10
save 60 10000

配置：保存文件路径 ​

redis
dbfilename dump.rdb
dir ./

方式2：日志（AOF）方式持久化 ​

配置：开启AOF ​

redis
appendonly yes

appendfilename "appendonly.aof"
appenddirname "appendonlydir"

appendfsync always
# appendfsync everysec
# appendfsync no
  • appendonly：是否开启AOF持久化，默认是no，不开启
  • appendfilename：AOF文件名，默认是appendonly.aof
  • appenddirname：AOF文件存放目录，默认是当前目录
  • appendfsync：AOF文件同步策略，默认是everysec，每秒同步一次
    • always：每次执行写入操作后立即同步
    • everysec：每秒同步一次
    • no：不进行同步

默认不开启（也就是appendonly no），不开启时Redis默认使用RDB方式持久化

  • 重启redis-server
redis
❯ redis-cli
127.0.0.1:6379> shutdown
not connected>
/opt/homebrew/opt/redis/bin/redis-server /opt/homebrew/etc/redis.conf

方式3：混合持久化（同时使用RDB和AOF） ​

  • 配置：开启AOF
redis
appendonly yes
  • 配置：开启混合持久化
redis
aof-use-rdb-preamble yes
  • 重启redis-server
redis
❯ redis-cli
127.0.0.1:6379> shutdown
not connected>
/opt/homebrew/opt/redis/bin/redis-server /opt/homebrew/etc/redis.conf

查看INFO信息 ​

redis
127.0.0.1:6379> info stats
...
latest_fork_usec:0
...
  • latest_fork_usec：最近一次fork操作耗时，单位微秒

慢查询 ​

  • 查看最近的10条慢查询日志：slowlog get 10
  • 查看慢查询日志的数量：slowlog len
  • 清空慢查询日志：slowlog reset
  • 配置：慢查询阈值，单位微秒：slowlog-log-slower-than 10000

配置命令 ​

  • 查看配置：CONFIG GET 配置项
  • 修改配置：CONFIG SET 配置项 值
redis
# 查看所有配置
127.0.0.1:6379> CONFIG GET *

# 设置最大内存为 4GB
127.0.0.1:6379> CONFIG SET maxmemory 4gb
最近更新