docker-compose up -d

services:
  redis:
    image: redis:7-alpine
    container_name: redis-practice
    restart: unless-stopped
    ports:
      - '6379:6379'
    volumes:
      - ./redis-data-t:/data
    command:
      - redis-server
      - --appendonly
      - 'yes'
      - --requirepass
      - '123456'
    healthcheck:
      test: ['CMD', 'redis-cli', '-a', '123456', 'ping']
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s

# 完整命令
redis-cli -h 127.0.0.1 -p 6379 -a password
# 简写
redis-cli
# 认证 进入redis之后
auth password

package main

import (
 "context"
 "fmt"
 "time"

 "github.com/redis/go-redis/v9"
)

var DB *redis.Client

func Connect() *redis.Client {
 redisDB := redis.NewClient(&redis.Options{
  Addr:        "127.0.0.1:6379", // 不写默认就是这个
  Password:    "123456",         // 密码
  DB:          1,                // 默认是0
  DialTimeout: time.Second,      // 连接超时
 })

 _, err := redisDB.Ping(context.Background()).Result()
 if err != nil {
  panic(err)
 }

 fmt.Println("Redis响应：", redisDB, err)

 return redisDB
}

127.0.0.1:6379> auth redis # 登录
OK
127.0.0.1:6379> set name leige # 设置
OK
127.0.0.1:6379> get name # 获取
"leige"
127.0.0.1:6379> exists name # 判断这个key是否存在
(integer) 1
127.0.0.1:6379> exists name1
(integer) 0
127.0.0.1:6379> del name # 删除这个key
(integer) 1
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> GETSET name1 lisi # 如果不存在值，则返回 nil，set是会执行的
(nil)
127.0.0.1:6379> GETSET name1 lisi # 如果存在值，获取原来的值，并设置新的值
"lisi"

127.0.0.1:6379> mset n1 zhangsan n2 lisi
OK
127.0.0.1:6379> get n1
"zhangsan"
127.0.0.1:6379> get n2
"lisi"

127.0.0.1:6379> get n
(nil)
127.0.0.1:6379> incr n # 自增1
(integer) 1 # 当前这个n的值
127.0.0.1:6379> get n
"1"
127.0.0.1:6379> incr n
(integer) 2
127.0.0.1:6379> get n
"2"
127.0.0.1:6379> decr n # 自减1
(integer) 1
127.0.0.1:6379> get n
"1"
127.0.0.1:6379> decr n
(integer) 0
127.0.0.1:6379> get n
"0"
127.0.0.1:6379> decr n
(integer) -1
127.0.0.1:6379> get n
"-1"

127.0.0.1:6379> get n
(nil)
127.0.0.1:6379> INCRBY n 10
(integer) 10
127.0.0.1:6379> INCRBY n 11
(integer) 21
127.0.0.1:6379> get n
"21"
127.0.0.1:6379> DECRBY n 5
(integer) 16
127.0.0.1:6379> get n
"16"

127.0.0.1:6379> setex name 20 leige
OK
127.0.0.1:6379> get name
"leige"
127.0.0.1:6379> ttl name # 查看还有多久过期
(integer) 12
127.0.0.1:6379> ttl name # -2表示已过期
(integer) -2
127.0.0.1:6379> get name
(nil)

127.0.0.1:6379> set name leige
OK
127.0.0.1:6379> ttl name # 现在是永不过期
(integer) -1
127.0.0.1:6379> expire name 10
(integer) 1
127.0.0.1:6379> ttl name
(integer) 6
127.0.0.1:6379> ttl name # 现在是过期了
(integer) -2

127.0.0.1:6379> rpush list zhangsan lisi wangwu xiaoming # 从右边向左边推入四个元素
4 # 返回列表的长度
127.0.0.1:6379> llen list # 查列表的长度
4
127.0.0.1:6379> lrange list 0 -1 # 查看列表的全部元素
zhangsan
lisi
wangwu
xiaoming
127.0.0.1:6379> rpop list # 从右边弹出一个元素
xiaoming
127.0.0.1:6379> lrange list 0 -1
zhangsan
lisi
wangwu
127.0.0.1:6379> lpop list # 从左边弹出一个元素
zhangsan
127.0.0.1:6379> lrange list 0 -1
lisi
wangwu

127.0.0.1:6379> hset dict name leige # 设置一个hash key，并且给hash里面设置一组filed value
0
127.0.0.1:6379> hget dict name # 获取hash里面对应filed的值
leige
127.0.0.1:6379> hgetall dict # 数据量大时，谨慎使用！获取在哈希表中指定 key 的所有字段和值
name
leige
127.0.0.1:6379> hkeys dict # 获取在哈希表中指定 key 的所有filed
name
127.0.0.1:6379> hmset info name leige age 23 # 批量设置
OK
127.0.0.1:6379> hkeys info
name
age
127.0.0.1:6379> HEXISTS info name # 判断某个field是否存在
1
127.0.0.1:6379> HEXISTS info name1
0
127.0.0.1:6379> HDEL info name # 删除hash中的一个filed
1
127.0.0.1:6379> hkeys info
age
127.0.0.1:6379> hlen info # 返回hash中filed的个数
1

127.0.0.1:6379> sadd set a b c d # 添加元素
4
127.0.0.1:6379> sadd set a b c e # 实际只有一个元素添加进去了
1
127.0.0.1:6379> scard set  # 获取集合的长度
5
127.0.0.1:6379> sismember set a # 判断某个元素是不是在集合里面
1
127.0.0.1:6379> sismember set f
0
127.0.0.1:6379> smembers set # 获取集合中的数据 无序的
e
d
b
a
c
127.0.0.1:6379> srem set a # 删除集合中的某个元素 可传多个
1

127.0.0.1:6379> sadd set1 1 2 3
3
127.0.0.1:6379> sadd set2 2 3 4
3
127.0.0.1:6379> sdiff set1 set2 # 差集
1
127.0.0.1:6379> sdiff set2 set1
4
127.0.0.1:6379> sinter set1 set2 # 交集
2
3
127.0.0.1:6379> sunion set1 set2 # 并集
1
2
3
4

127.0.0.1:6379> sadd order 1 2 3 4 5 6 7 8
8
127.0.0.1:6379> spop order # 随机移除一个
5
127.0.0.1:6379> spop order
7
127.0.0.1:6379> spop order 3 # 随机移除3个，redis3.2+支持

127.0.0.1:6379> zadd class 88 leige 46 zhangsan 76 wangwu 36 lisi # 向有序集合添加一个或多个成员
(integer) 4
127.0.0.1:6379> zrange class 0 -1 # 通过索引，按照分数从低到高返回
1) "lisi"
2) "zhangsan"
3) "wangwu"
4) "leige"
127.0.0.1:6379> zrevrange class 0 -1 # 通过索引，按照分数从高到低返回
1) "leige"
2) "wangwu"
3) "zhangsan"
4) "lisi"
127.0.0.1:6379> zcard class # 获取有序集合的成员数
(integer) 4
127.0.0.1:6379> ZSCORE class zhangsan # 查看某个成员的分数
"46"
127.0.0.1:6379> ZRANK class wangwu # 查看成员的排名 从小到大排序
(integer) 2
127.0.0.1:6379> ZREVRANK class wangwu # 查看成员的排名 从大到小排序
(integer) 1
127.0.0.1:6379> zcount class 40 70 # 计算在有序集合中指定区间分数的成员数
(integer) 1
127.0.0.1:6379> zrangebyscore class 40 70 # 通过分数返回有序集合指定区间内的成员
1) "zhangsan"
127.0.0.1:6379> zrevrangebyscore class 100 0 # 返回有序集中指定分数区间内的成员，分数从高到低排序
1) "leige"
2) "wangwu"
3) "zhangsan"
4) "lisi"
127.0.0.1:6379> zrange class 0 -1 withscores # 把成员和分数一起显示出来
1) "lisi"
2) "36"
3) "zhangsan"
4) "46"
5) "wangwu"
6) "76"
7) "leige"
8) "88"
127.0.0.1:6379> zrem class leige # 移除一个成员
(integer) 1
127.0.0.1:6379> zrange class 0 -1
1) "lisi"
2) "zhangsan"
3) "wangwu"
127.0.0.1:6379> ZREMRANGEBYRANK class 0 0 # 移除有序集合中给定的排名区间的所有成员(第一名是0)(低到高排序)
(integer) 1
127.0.0.1:6379> zrange class 0 -1
1) "zhangsan"
2) "wangwu"
127.0.0.1:6379> ZREMRANGEBYSCORE class 40 50 # 移除有序集合中给定的分数区间的所有成员
(integer) 1
127.0.0.1:6379> zrange class 0 -1
1) "wangwu"
127.0.0.1:6379> ZSCORE class wangwu
"76"
127.0.0.1:6379> ZINCRBY class 2 wangwu # 给wangwu分数+2
"78"
127.0.0.1:6379> ZINCRBY class -2 wangwu # 给wangwu分数‑2
"76"

// string类型基本操作
func RedisStringOperations(client *redis.Client) {
	// 创建一个带超时的 context，防止网络请求卡死（推荐10秒超时）
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel() // 请求结束时释放 context 资源

	// 1. Set 和 Get
	client.Set(ctx, "name", "Lin", 0)

	val, _ := client.Get(ctx, "name").Result()
	fmt.Println("获取的 name 值:", val) // 输出: Lin

	// 2. Exists 检查 Key 是否存在
	existsName, _ := client.Exists(ctx, "name").Result()
	existsName1, _ := client.Exists(ctx, "name1").Result()
	fmt.Println("name 是否存在:", existsName == 1, "\nname1 是否不存在:", existsName1 == 0) // 输出: 1 0

	// 3. 数值自增操作 (Redis 要求值必须是纯数字字符串)
	client.Set(ctx, "age", "12", 0)

	client.Incr(ctx, "age")       // 12 + 1 = 13
	client.IncrBy(ctx, "age", 10) // 13 + 10 = 23

	ageVal, _ := client.Get(ctx, "age").Int64()
	fmt.Println("自增后的 age 值:", ageVal) // 输出: 23

	// 4. TTL 过期时间操作
	ttl, _ := client.TTL(ctx, "name").Result()
	fmt.Println("name 的当前过期时间:", ttl) // 输出: -1s (代表永不过期)

	// 设置 2 秒过期时间
	client.Expire(ctx, "name", 2*time.Second)
	ttl, _ = client.TTL(ctx, "name").Result()
	fmt.Println("设置过期后的 TTL:", ttl) // 输出: 约 2s

	// 等待 2 秒让 Key 过期
	time.Sleep(2 * time.Second)
	ttl, _ = client.TTL(ctx, "name").Result()
	fmt.Println("过期后的 TTL:", ttl) // 输出: -2s (代表 Key 不存在)
}

// List 基础操作
func RedisListOperations(client *redis.Client) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	client.LTrim(ctx, "list", 1, 0) // 先清空，保证重复运行结果稳定

	// 1. 从右边入队，插入4个元素
	client.RPush(ctx, "list", "TS", "Rust", "Python", "Zig")

	// 2. 获取列表长度
	length := client.LLen(ctx, "list").Val()
	fmt.Println("列表长度:", length) // 输出: 4

	// 3. 获取列表所有元素 (索引从 0 到 -1 代表全部)
	vals := client.LRange(ctx, "list", 0, -1).Val()
	fmt.Println("列表所有元素:", vals)
}

// Hash类型
func RedisHash(client *redis.Client) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 设置哈希字段
	client.HSet(ctx, "info", "文章1", 23)

	// 获取单个字段，转成 int64
	val, _ := client.HGet(ctx, "info", "文章1").Int64()
	fmt.Println(val) // 23

	// 获取整个哈希表
	fmt.Println(client.HGetAll(ctx, "info").Val()) // map[文章1:23]

	// 获取所有字段名
	fmt.Println(client.HKeys(ctx, "info").Val()) // [文章1]

	// 判断字段是否存在
	fmt.Println(client.HExists(ctx, "info", "文章1").Val()) // true
	fmt.Println(client.HExists(ctx, "info", "文章2").Val()) // false

	// 获取字段数量
	fmt.Println(client.HLen(ctx, "info").Val()) // 1
}

// Set 类型
func RedisSet(client *redis.Client) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 添加元素
	client.SAdd(ctx, "set", "a", "b", "c", "d")

	// 判断是否是成员
	fmt.Println(client.SIsMember(ctx, "set", "a").Val()) // true

	// 获取所有成员（无序）
	fmt.Println(client.SMembers(ctx, "set").Val()) // [b d c a]

	// 准备两个集合做集合运算
	client.SAdd(ctx, "set1", 1, 2, 3)
	client.SAdd(ctx, "set2", 2, 3, 4)

	// 差集：set1 里有但 set2 里没有的
	fmt.Println(client.SDiff(ctx, "set1", "set2").Val()) // [1]

	// 交集：两个集合都有的
	fmt.Println(client.SInter(ctx, "set1", "set2").Val()) // [2 3]

	// 并集：两个集合所有不重复的元素
	fmt.Println(client.SUnion(ctx, "set1", "set2").Val()) // [1 2 3 4]
}

// ZSet 类型
func RedisZSet(client *redis.Client) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 0. 先清空，保证重复运行的结果稳定
	client.Del(ctx, "class")

	// 1. 添加成员和分数 (传入切片)
	zs := []redis.Z{
		{Score: 80, Member: "张三"},
		{Score: 46, Member: "李四"},
	}
	client.ZAdd(ctx, "class", zs...)

	// 2. 按排名从小到大取全部成员 (索引 0 到 -1)
	fmt.Println(client.ZRange(ctx, "class", 0, -1).Val())
	// [李四 张三]

	// 3. 按排名从大到小取全部成员
	// V9 中 ZRevRange 已废弃，统一用 ZRangeArgs + Rev
	fmt.Println(client.ZRangeArgs(ctx, redis.ZRangeArgs{
		Key:   "class",
		Start: 0,
		Stop:  -1,
		Rev:   true, // 反转，即从大到小
	}).Val())
	// [张三 李四]

	// 4. 按分数范围查询：0~100，从小到大
	// V9 中 ZRangeByScore 已废弃(Redis 6.2.0+)，改用 ZRangeArgs + ByScore
	// Start/Stop 此时是分数边界，所以用字符串
	fmt.Println(client.ZRangeArgs(ctx, redis.ZRangeArgs{
		Key:     "class",
		Start:   "0",
		Stop:    "100",
		ByScore: true, // 按分数区间查，而不是按排名下标查
	}).Val())
	// [李四 张三]

	// 5. 按分数范围查询：0~100，从大到小
	// 注意：ByScore + Rev 时，Start 必须写较大的分数、Stop 写较小的分数（区间要反着写）
	fmt.Println(client.ZRangeArgs(ctx, redis.ZRangeArgs{
		Key:     "class",
		Start:   "100",
		Stop:    "0",
		ByScore: true,
		Rev:     true, // 反转
	}).Val())
	// [张三 李四]

	// 6. 带分数一起查出来
	// 用 ZRangeArgsWithScores 替代旧写法，返回 []redis.Z（含 Member 和 Score）
	fmt.Println(client.ZRangeArgsWithScores(ctx, redis.ZRangeArgs{
		Key:     "class",
		Start:   "0",
		Stop:    "100",
		ByScore: true,
	}).Val())
	// [{46 李四} {80 张三}]  ← redis.Z 的字段顺序是 Score 在前、Member 在后

	// 7. 查询指定成员的分数
	fmt.Println(client.ZScore(ctx, "class", "李四").Val())
	// 46
}

127.0.0.1:6379> select 2 # 切换数据库
OK
127.0.0.1:6379[2]> select 0
OK
127.0.0.1:6379> keys * # 查看所有的key
1) "zset"
2) "order"
127.0.0.1:6379> keys s* # 查看s开头的key
1) "set"
2) "set2"
3) "set1"
127.0.0.1:6379> ping # 查看服务是否运行
PONG
127.0.0.1:6379> move name 1 # 将当前数据库的key移动到数据库1当中
(integer) 1
127.0.0.1:6379[1]> PERSIST name # 移除key的过期时间，key永不过期
(integer) 1
127.0.0.1:6379[1]> type name # 查看key的数据类型
string
127.0.0.1:6379[1]> type info
hash
127.0.0.1:6379[1]> type class
zset
127.0.0.1:6379[1]> type set
set
127.0.0.1:6379[1]> type list
list
127.0.0.1:6379[1]> CLIENT LIST # 获取连接到服务器的客户端连接列表
id=4 addr=127.0.0.1:52377 fd=7 name= age=5 idle=3 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=client
127.0.0.1:6379[1]> dbsize # 获取当前数据库key的数量
(integer) 5
127.0.0.1:6379[1]> FLUSHDB # 删除当前数据库的所有key
OK
127.0.0.1:6379[1]> FLUSHALL # 删除全部数据库的所有key
OK

127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set name ff
QUEUED
127.0.0.1:6379> get name
QUEUED
127.0.0.1:6379> exec # 执行事务
1) OK
2) "ff"

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set age 12
QUEUED
127.0.0.1:6379> discard # 取消事务
OK
127.0.0.1:6379> get age # 数据未改动
(nil)

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set age 12
QUEUED
127.0.0.1:6379> x
(error) ERR unknown command 'x'
127.0.0.1:6379> get age
QUEUED
127.0.0.1:6379> exec
(error) EXECABORT Transaction discarded because of previous errors.

// Redis事务
func RedisPipelineAndAtomicty(client *redis.Client) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// ==========================================
	// 1. Redis Pipeline (管道) 演示
	// ==========================================
	// 作用：把多条命令打包，一次性发给 Redis 服务器，再一次性读回结果。
	// 好处：极大地减少了网络往返次数，提高了高并发下的吞吐量。
	fmt.Println("=== 1. Pipeline 管道演示 ===")

	// 获取一个管道对象（TxPipeline 会保证命令不被其他客户端打断，但无法回滚）
	pipe := client.TxPipeline()

	// 将命令写入管道（此时还没有真正发送给 Redis）
	pipe.Set(ctx, "pipeline_name", "磊哥", 0)
	val := pipe.Get(ctx, "pipeline_name")

	// ⚠️ 注意：这里打印不出结果！因为命令还在内存管道里，没发给 Redis。
	fmt.Println("[管道未提交] 结果:", val.Val()) // 输出为空

	// 一次性将管道里的所有命令发送到 Redis 执行，并获取结果
	_, err := pipe.Exec(ctx)
	if err != nil {
		fmt.Println("提交管道事务失败:", err)
		return
	}

	// 命令执行完毕后，现在可以通过之前的 val 拿到结果了
	fmt.Println("[管道已提交] 结果:", val.Val()) // 输出: 磊哥

	// ==========================================
	// 2. 核心对比与局限性解析 (注释详解)
	// ==========================================
	fmt.Println("\n=== 2. 核心对比解析 ===")

	/*
		🔴 Redis 原生事务 (TxPipeline) 的致命局限：
		1. 无法回滚：Redis 事务没有 "ROLLBACK" 机制。如果在 EXEC 执行期间，
		   中间某条命令报错（例如用 Get 命令去操作一个 Hash 类型的 key），
		   Redis 会忽略这个错误，继续把后面所有的命令执行完。
		2. 不支持条件逻辑：事务里只能排队执行命令。你不能写 "如果 key 存在就删除，
		   不存在就赋值" 这种带 if/else 逻辑的脚本。
		👉 适用场景：多条命令之间没有逻辑依赖，仅仅为了减少网络请求次数（批量处理）。
	*/

	/*
		🟡 为什么 Lua 脚本更常用？
		Lua 脚本将 "读取 -> 业务判断 -> 写入" 打包成一个整体。
		Redis 在执行 Lua 脚本时，会把其他所有客户端的命令都挂起。
		👉 适用场景：实现真正的业务原子性。例如：扣减库存（先判断库存够不够，够就减）、
		   分布式锁的安全释放（GET 比对 value，匹配才 DEL，防止误删别人的锁）。
	*/

	/*
		🟢 什么时候用 Lock (分布式锁)？
		Lock 不是用来做数据计算的，而是用来做 "互斥资源控制" 的。
		👉 适用场景：防止并发问题。例如：高并发抢购时，防止同一个用户生成多笔订单；
		   多个微服务同时去定时任务，只允许其中一个执行。
	*/
}

// Lua脚本
func RedisLuaScript(client *redis.Client) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 1. 模拟加锁
	client.Set(ctx, "my_lock", "张三", 30*time.Second)
	fmt.Println("当前锁的持有者:", client.Get(ctx, "my_lock").Val())

	// 2. 编写 Lua 脚本
	// 逻辑：先读锁的值(KEYS[1])，如果等于传入的值(ARGV[1])就删除它，返回1(成功)；否则返回0(失败)
	unlockScript := `
        if redis.call("GET", KEYS[1]) == ARGV[1] then
            return redis.call("DEL", KEYS[1])
        else
            return 0
        end
    `

	// 3. 尝试用 Lua 脚本安全释放锁
	// 场景 A: 持有者确实是 "张三"，应该删除成功
	resultA := client.Eval(ctx, unlockScript, []string{"my_lock"}, "张三")
	fmt.Println("场景A(正确持有者)释放结果:", resultA.Val()) // 输出: 1

	// 4. 重新上锁
	client.Set(ctx, "my_lock", "李四", 30*time.Second)

	// 场景 B: "王五" 假装自己是持有者来解锁，应该失败
	resultB := client.Eval(ctx, unlockScript, []string{"my_lock"}, "王五")
	fmt.Println("场景B(错误持有者)释放结果:", resultB.Val())             // 输出: 0
	fmt.Println("验证锁是否还在:", client.Get(ctx, "my_lock").Val()) // 输出: 李四 (锁没有被误删)
}

127.0.0.1:6379[1]> set price 100
OK
127.0.0.1:6379[1]> WATCH price // 检测这个key，如果key在事务期间发生了变化，则事务不成功
OK
127.0.0.1:6379[1]> MULTI
OK
127.0.0.1:6379[1]> set price 101
QUEUED
127.0.0.1:6379[1]> get price
QUEUED
127.0.0.1:6379[1]> exec // 在exec之前，再用一个客户端去修改这个price的值，exec返回nil
(nil)

// Watch 乐观锁
func RedisWatch(client *redis.Client) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	key := "price"

	// 为了方便测试，先给 price 设个初始值
	client.Set(ctx, key, 100, 0)

	fmt.Println("=== 乐观锁 (Watch) 机制演示 ===")
	fmt.Println("初始价格:", client.Get(ctx, key).Val())

	// ==========================================
	// Watch 核心机制：监听 key，并在事务中提交更改
	// ==========================================
	err := client.Watch(ctx, func(tx *redis.Tx) error {
		// 1. 读取当前值 (在 Redis 内部完成)
		n, err := tx.Get(ctx, key).Int()
		if err != nil && err != redis.Nil {
			return err
		}

		// 2. 模拟业务处理耗时（比如去算账）
		// 在这 3 秒钟内，如果有其他客户端修改了 price，这次事务就会自动失败。
		fmt.Println(">>> 正在处理价格业务，预计耗时3秒...")
		time.Sleep(3 * time.Second)

		// 3. 提交更改 (price + 1)
		_, err = tx.Pipelined(ctx, func(pipe redis.Pipeliner) error {
			pipe.Set(ctx, key, n+1, 0)
			return nil
		})
		return err
	}, key)

	// 4. 打印最终结果
	if err != nil {
		fmt.Println("❌ 事务提交失败！因为在这期间 price 被其他客户端修改了，自动回滚。")
	} else {
		fmt.Println("✅ 事务提交成功！当前价格已更新。")
	}
	fmt.Println("最终价格:", client.Get(ctx, key).Val())
}

# 加锁：成功返回 OK，失败返回 nil
127.0.0.1:6379> SET lock:order:1001 user-A NX EX 30
OK
# key 已存在，NX 条件不满足，加锁失败
127.0.0.1:6379> SET lock:order:1001 user-B NX EX 30
(nil)

# 老式写法：SETNX 只能"设置"，不能同时设置过期，两步之间可能死锁
127.0.0.1:6379> SETNX lock:order:1001 user-A
(integer) 1
127.0.0.1:6379> EXPIRE lock:order:1001 30
(integer) 1

// 分布式锁 (SET NX)
func RedisDistributedLockNX(client *redis.Client) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	key := "lock:order:1001" // 锁的 key，一般用"业务前缀 + 资源 id"命名
	// 锁的 value 必须每个持有者唯一，释放时才能校验"这是不是我的锁"
	// （真实项目里通常用 UUID / 请求 id，这里用时间戳模拟）
	token := fmt.Sprintf("user-A-%d", time.Now().UnixNano())

	// 先删掉上次运行残留的锁，保证重复运行结果稳定
	client.Del(ctx, key)

	fmt.Println("=== 分布式锁 (SET NX) 机制演示 ===")

	// ==========================================
	// 1. 错误示范：SETNX + EXPIRE 分成两条命令
	// ==========================================
	// 问题：两条命令之间如果程序崩溃或网络中断，过期时间没设上，
	// 这个 key 就永远存在，别人再也拿不到锁 → 死锁。
	// 而且 SETNX 本身也是非原子的（只能"设置"，不能"设置 + 过期"一起做）。
	ok, err := client.SetNX(ctx, key, token, 0).Result() // 0 表示不设过期时间
	if err != nil {
		fmt.Println("① SetNX 执行出错:", err)
		return
	}
	fmt.Println("① SetNX 是否拿到锁:", ok) // true
	client.Expire(ctx, key, 30*time.Second)
	fmt.Println("① 补设过期时间 TTL:", client.TTL(ctx, key).Val()) // 30s

	// ==========================================
	// 2. 正确姿势：SET key value NX EX 一步到位（原子操作）
	// ==========================================
	// 用 SetArgs + Mode:"NX" + TTL，等价于命令：SET key value NX EX 30
	// 加锁失败不是"报错"，而是返回 redis.Nil（表示 key 已存在，没抢到）
	client.Del(ctx, key) // 先释放上面的锁，方便演示

	_, err = client.SetArgs(ctx, key, token, redis.SetArgs{
		Mode: "NX",             // 仅当 key 不存在时才设置
		TTL:  30 * time.Second, // 同时设置过期时间，防止持锁者崩溃导致死锁
	}).Result()
	if err == redis.Nil {
		fmt.Println("② 加锁失败：锁已被其他客户端持有")
	} else if err != nil {
		fmt.Println("② 加锁出错:", err)
		return
	} else {
		fmt.Println("② 加锁成功，锁的持有者:", client.Get(ctx, key).Val()) // user-A-xxx
	}

	// ==========================================
	// 3. 模拟另一个客户端来抢同一把锁，必然失败
	// ==========================================
	_, err = client.SetArgs(ctx, key, "user-B", redis.SetArgs{
		Mode: "NX",
		TTL:  30 * time.Second,
	}).Result()
	fmt.Println("③ 客户端B 是否抢到锁:", err != redis.Nil) // false，抢锁失败

	// ==========================================
	// 4. 释放锁：先比对 value，确认是自己的锁再删，否则会误删别人的锁
	// ==========================================
	// 复用 Lua 脚本实现"读-判断-删"的原子性，思路和 RedisLuaScript 里的解锁完全一致
	unlockScript := `
        if redis.call("GET", KEYS[1]) == ARGV[1] then
            return redis.call("DEL", KEYS[1])
        else
            return 0
        end
    `

	// 场景 A: 用错误的 token 释放，应该失败，锁完好无损
	resultA := client.Eval(ctx, unlockScript, []string{key}, "user-B")
	fmt.Println("④ 错误持有者尝试释放:", resultA.Val())             // 0
	fmt.Println("   验证锁是否还在:", client.Get(ctx, key).Val()) // user-A-xxx

	// 场景 B: 用正确的 token 释放，应该成功
	resultB := client.Eval(ctx, unlockScript, []string{key}, token)
	fmt.Println("④ 正确持有者释放锁:", resultB.Val())                  // 1
	fmt.Println("   释放后锁是否存在:", client.Exists(ctx, key).Val()) // 0
}

dbfilename dump.rdb
dir ./

save 3600 1
save 300 100
save 60 10000

appendonly yes
appendfilename "appendonly.aof"
# appendfsync always
appendfsync everysec
# appendfsync no
dir ./