Redis实战(下)|青训营排行榜积分变化时，排名要实时变更结合dict后，可实现通过key操作跳表的功能这一部分

排行榜

积分变化时，排名要实时变更

结合dict后，可实现通过key操作跳表的功能

这一部分主要是针对有序集合的一个练习，改结构体中主要需要两个参数一个就是成员名，另一个为分数，形如这样：

type Z struct {
    Score  float64
    Member interface{}
}

可以将数据存入切片中，通过ZAdd接口实现数据的添加，注意这个接口可以实现数据的批量存入，所以只需要写成initList...的形式即可放入所有数据，下面是封装好的init接口：

func Ex04InitUserScore(ctx context.Context) {
    initList := []redis.Z{
        {Member: "user1", Score: 10}, {Member: "user2", Score: 232}, {Member: "user3", Score: 129},
        {Member: "user4", Score: 232},
    }
    if err := RedisClient.Del(ctx, Ex04RankKey).Err(); err != nil {
        panic(err)
    }
    nums, err := RedisClient.ZAdd(ctx, Ex04RankKey, initList...).Result()
    if err != nil {
        panic(err)
    }
    fmt.Printf("初始化榜单Item数量：%d\n", nums)
}

如果想到得到已有的数据排名，redis给出了响应的接口函数，可参考以下这个方式获得想要的数据，如果需要获得所有的数据，则通过指明0，-1即可

zrange ex06_rank_zset 300 0 byscore rev limit 1 2 withscores // 取300分到0分之间的排名

zrange ex06_rank_zset -inf +inf byscore withscores 正序输出

ZRANGE ex06_rank_zset +inf -inf BYSCORE REV WITHSCORES 逆序输出所有排名

zrange ex06_rank_zset +inf -inf byscore rev limit 0 2 withscores 逆序分页输出排名

func GetRevOrderAllList(ctx context.Context, limit, offset int64) {
    resList, err := RedisClient.ZRevRangeWithScores(ctx, Ex04RankKey, 0, -1).Result()
    if err != nil {
        panic(err)
    }
    fmt.Printf("\n榜单：\n")
    for i, z := range resList {
        fmt.Printf("第%d名 %s\t%f\n", i+1, z.Member, z.Score)
    }
}

如果想查看单个用户的排名或者分数可以通过ZRevRank ZScore实现，这两个接口会返回需要的排名或者对应的分数

如果想更改单个用户的分数，可以通过ZIncrBy接口更改数据

zset数据结构zskiplist

限流

要求1秒内放行的请求为N，超过N则禁止访问

这部分的实现需要用到并发协程的设计思想，但我们已经在之前设计好了，所以只需要设计真正的执行函数即可，这里我们的函数主体为ex05work在这个函数的实现相对简单，首先根据传时间创建唯一的key将改key放入redis中，它会返回当前key对应的值，因为我们可以同时启动很多的协程在同一秒内，对一个key的访问可能会很高，通过其看会的值是否大于10即可首先对应的协程是否被限流，其函数主体如下：

func ex05work(ctx context.Context, cParams common.CInstParams) {
    routeKey := cParams.Routine
    eventlog := cParams.ConcurrentEventLogger
    limitKey := ex05LimitKey(time.Now())
    currentQFX, err := RedisClient.Incr(ctx, limitKey).Result()
    if err != nil || err == redis.Nil {
        err = RedisClient.Incr(ctx, ex05LimitKey(time.Now())).Err()
        if err != nil {
            panic(err)
        }
    }
    if currentQFX > ex05MaxQPS {
        eventlog.Append(common.EventLog{
            EventTime: time.Now(),
            Log:       common.LogFormat(routeKey, "被限流[%d", currentQFX),
        })
        time.Sleep(50 * time.Millisecond)
        err = RedisClient.Decr(ctx, limitKey).Err()
        if err != nil {
            panic(err)
        }
    } else {
        eventlog.Append(common.EventLog{
            EventTime: time.Now(),
            Log:       common.LogFormat(routeKey, "流量放行[%d]", currentQFX),
        })
        atomic.AddInt32(&accessQueryNum, 1)
        time.Sleep(20 * time.Millisecond)
    }
}

func Ex05(ctx context.Context) {
    eventlogger := &common.ConcurrentEventLogger{}
    cInst := common.NewConcurrentRoutine(500, eventlogger)
    cInst.Run(ctx, Ex05Params{}, ex05work)
    eventlogger.PrintLogs()
    fmt.Printf("放行总数：%d\n", accessQueryNum)
    fmt.Printf("\n------\n下一秒请求\n------\n")
    accessQueryNum = 0
    time.Sleep(1 * time.Second)
    cInst = common.NewConcurrentRoutine(10, eventlogger)
    cInst.Run(ctx, Ex05Params{}, ex05work)
    eventlogger.PrintLogs()
    fmt.Printf("放行总数：%d\n", accessQueryNum)
}

分布式锁

并发场景，要求一次只能有一个协程执行，执行完成后，其它等待中的协程才能执行，可以使用redis的setnx实现，利用了两个特性

Redis是单线程执行命令
setnx只有未设置过才能执行成功

这一部分实现方式也是主要针对的是回调函数，回调函数中应该实现针SetNX Get Del等一系列操作，对于这几个接口的解释可参考如下：

SETNX:用于设置键的值，但仅在该键不存在时执行
GET:获取对应的键值对应的值
DEL删除个键值

func ex06work(ctx context.Context, cInstParam common.CInstParams) {
    routine := cInstParam.Routine
    eventLogger := cInstParam.ConcurrentEventLogger
    defer ex06ReleaseLock(ctx, routine, eventLogger)
    for {
        acquired, err := RedisClient.SetNX(ctx, resourceKey, routine, exp).Result()
        if err != nil {
            eventLogger.Append(common.EventLog{
                EventTime: time.Now(), Log: fmt.Sprintf("[%s] error routine[%d], %v", time.Now().Format(time.RFC3339Nano), routine, err),
            })
            panic(err)
        }
        if acquired {
            // 2. 成功获取锁
            eventLogger.Append(common.EventLog{
                EventTime: time.Now(), Log: fmt.Sprintf("[%s] routine[%d] 获取锁", time.Now().Format(time.RFC3339Nano), routine),
            })
            // 3. sleep 模拟业务逻辑耗时
            time.Sleep(10 * time.Millisecond)
            eventLogger.Append(common.EventLog{
                EventTime: time.Now(), Log: fmt.Sprintf("[%s] routine[%d] 完成业务逻辑", time.Now().Format(time.RFC3339Nano), routine),
            })
            return
        } else {
            time.Sleep(100 * time.Millisecond)
        }

    }
}
func ex06ReleaseLock(ctx context.Context, routine int, eventLogger *common.ConcurrentEventLogger) {
    routineMark, _ := RedisClient.Get(ctx, resourceKey).Result()
    if strconv.FormatInt(int64(routine), 10) != routineMark {
        // 其它协程误删lock
        panic(fmt.Sprintf("del err lock[%s] can not del by [%d]", routineMark, routine))
    }
    set, err := RedisClient.Del(ctx, resourceKey).Result()
    if set == 1 {
        eventLogger.Append(common.EventLog{
            EventTime: time.Now(), Log: fmt.Sprintf("[%s] routine[%d] 释放锁", time.Now().Format(time.RFC3339Nano), routine),
        })
    } else {
        eventLogger.Append(common.EventLog{
            EventTime: time.Now(), Log: fmt.Sprintf("[%s] routine[%d] no lock to del", time.Now().Format(time.RFC3339Nano), routine),
        })
    }
    if err != nil {
        fmt.Errorf("[%s] error routine=%d, %v", time.Now().Format(time.RFC3339Nano), routine, err)
        panic(err)
    }
}

Redis使用注意事项

大key，热key

大key的危害：

读取成本高
容易导致慢查询(过期，删除)
主从复制异常，服务阻塞无法正常响应请求

消除大key的方法

拆分

将大key拆分为小key，例如一个string拆分成多个string

2. 压缩

将value压缩后写入redis,读取时解压后在使用，压缩算法可以是gzip,snappy,lz4更，通常情况下，一个压缩算法压缩率高，则解压耗时就长，需要对实际数据进行测试后，选择一个合适的算法，如果存储的是JSON字符串，可以考虑使用MessagePack进行序列化

3.   集合类结构hash,list,set,
  - 拆分：可以用hash取余、位掩码的方式决定放在哪个key中
  - 区分冷热：如榜单列表场景使用zset,只缓存前10页数据，后续数据走db

热key的定义

用户访问一个Key的QPS特别高，导致Server实例出现cPU负载突增或者不均的情况。热key没有明确的标准，QPS超过500就有可能被识别为热Key。

热key的解决方式

设置Localcache

在访问Redis前，在业务服务侧设置Localcache,降低访问Redis的QPS。LocalCache中缓存过期或未命中，则从Redis中将数据更新到LocalCache。Java的Guava、Golang的Bigcache就是这类LocalCache。

拆分

将key:valuei这一个热Key复制写入多份，例如key1:value,key2:value,访问的时候访问多个key,但value,是同一以此将qs分散到不同实例上，降低负载。代价是，更新时需要更新多个key,存在数据短暂不一致的风险。

3. 使用Redis代理的热key承载能力

字节跳动的Redisi访问代理就具备热Key承载能力。本质上是结合了“热Key发现”、“LocalCache"两个功能

慢查询场景

容易导致redis慢查询的操作

批量操作一次性传入过多的key/value,如mset/hmset//sadd/zadd等o(n)操作，建议单批次不要超过100，超过100之后性能下降明显。
zset大部分命令都是0(logn),当大小超过5k以上时，简单的zadd/zrem也可能导致慢查询
操作的单个valuej过大，超过10KB。也即，避免使用大Key
对大key的delete/expire操作也可能导致慢查询，Redis44.O之前不支持异步删除unlink,大key删除会阻塞Redis

缓存穿透、缓存雪崩

缓存穿透：热点数据查询绕过缓存，直接查询数据库
缓存雪崩：大量缓存同时过期

缓存穿透的危害

查询一个一定不存在的数据通常不会缓存不存在的数据，这类查询请求都会直接打到b，,如果有系统bug或人为攻击，那么容易导致b响应慢甚至宕机
缓存过期时在高并发场景下，一个热key如果过期，会有大量请求同时击穿至db,容易影响db性能和稳定。

同一时间有大量key集中过期时，也会导致大量请求落到db上，导致查询变慢，甚至出现b无法响应新的查询

如何减少缓存穿透

缓存空值如一个不存在的userID。这个id在缓存和数据库中都不存在。则可以缓存一个空值，下次再查缓存直接反空值，
布隆过滤器通过bloom filter?算法来存储合法Key,得益于该算法超高的压缩率，只需占用极小的空间就能存储大量key值

如何避免缓冲雪崩

缓存空值将缓存失效时间分散开，比如在原有的失效时间基础上增加一个随机值，例如不同Key过期时间可以设置为10分1秒过期，10分23秒过期，10分8秒过期。单位秒部分就是随机时间，这样过期时间就分散了对于热点数据，过期时间尽量设置得长一些，冷门的数据可以相对设置过期时间短一些。
使用缓存集群，避免单机宕机造成的缓存雪崩。