基于Redis 千万级用户排行榜最佳实践

基于Redis 千万级用户排行榜最佳实践

前言

Redis 是一个开源的，内存中的数据结构存储系统，可以用作数据库、缓存和消息队列中间件。它支持多种类型的数据结构，如 字符串（string）， Hash， 列表（List）， 集合（Set）， 有序集合（Sorted Set) 。 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务(Transactions） 和不同级别的 磁盘持久化(Persistence)， 并通过 Redis哨兵(Sentinel)和自动分区(Cluster)提供高可用性

根据Redis支持的几大数据结构, 我们可以在多个场景加以应用, 目前应用最广泛的场景主要用于以下几大类:

基于Web服务的分布式会话Session存储

消息队列

排行榜

计数器

发布/订阅

此文主要讲解个人是如何处理千万级别用户排行榜并持久化用户排行榜用户数据

排行榜种类

由于排行榜的不同业务需求, 需要从不同角度去考虑排行榜的榜单生成规则. 目前我们主要研究实时榜和历史榜单

排行榜Redis数据结构选择

在这里, 我们采用Redis Sorted Set数据结构来处理排行榜数据, 根据官方文档定义:

Redis Sorted sets —
Sorted sets are a data type which is similar to a mix between a Set and a Hash. Like sets, sorted sets are composed of unique, non-repeating string elements, so in some sense a sorted set is a set as well.

​ However while elements inside sets are not ordered, every element in a sorted set is associated with a floating point value, called the score (this is why the type is also similar to a hash, since every element is mapped to a value).

​ 然而，虽然Set中的元素没有被排序，但排序集中的每个元素都与一个浮点值相关联，这个值称为得分（这也是为什么该类型与哈希类似，因为每个元素都映射到一个值）。

​ Moreover, elements in a sorted sets are taken in order (so they are not ordered on request, order is a peculiarity of the data structure used to represent sorted sets). They are ordered according to the following rule:

​ 此外，Sorted Set中的元素是按顺序排列的（而不是按加入的先后顺序排序的，并且这个顺序是用于表示排序集的数据结构的一个特性）。

​ 在Sorted Set中添加、删除或更新一个成员都是非常快速的操作，其时间复杂度为集合中成员数量的对数。由于Sorted Set中的成员在集合中的位置是有序的，因此，即便是访问位于集合中部的成员也仍然是非常高效的。

Sorted Set底层的实现是跳跃表(Skip List),插入和删除的效率都很高.

在redis的源码中，找到zset的定义如下(server.h)：

/* ZSETs use a specialized version of Skiplists */
typedef struct zskiplistNode {
    sds ele;
    double score;
    struct zskiplistNode *backward;
    struct zskiplistLevel {
        struct zskiplistNode *forward;
        unsigned int span;
    } level[];
} zskiplistNode;

typedef struct zskiplist {
    struct zskiplistNode *header, *tail;
    unsigned long length;
    int level;
} zskiplist;

typedef struct zset {
    dict *dict;
    zskiplist *zsl;
} zset;

插入节点对应的方法源码(t_zset.c)：

/* Insert a new node in the skiplist. Assumes the element does not already
 * exist (up to the caller to enforce that). The skiplist takes ownership
 * of the passed SDS string 'ele'. */
zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;

    serverAssert(!isnan(score));
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        /* store rank that is crossed to reach the insert position */
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
        while (x->level[i].forward &&
                (x->level[i].forward->score < score ||
                    (x->level[i].forward->score == score &&
                    sdscmp(x->level[i].forward->ele,ele) < 0)))
        {
            rank[i] += x->level[i].span;
            x = x->level[i].forward;
        }
        update[i] = x;
    }
    /* we assume the element is not already inside, since we allow duplicated
     * scores, reinserting the same element should never happen since the
     * caller of zslInsert() should test in the hash table if the element is
     * already inside or not. */
    level = zslRandomLevel();
    if (level > zsl->level) {
        for (i = zsl->level; i < level; i++) {
            rank[i] = 0;
            update[i] = zsl->header;
            update[i]->level[i].span = zsl->length;
        }
        zsl->level = level;
    }
    x = zslCreateNode(level,score,ele);
    for (i = 0; i < level; i++) {
        x->level[i].forward = update[i]->level[i].forward;
        update[i]->level[i].forward = x;

        /* update span covered by update[i] as x is inserted here */
        x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
        update[i]->level[i].span = (rank[0] - rank[i]) + 1;
    }

    /* increment span for untouched levels */
    for (i = level; i < zsl->level; i++) {
        update[i]->level[i].span++;
    }

    x->backward = (update[0] == zsl->header) ? NULL : update[0];
    if (x->level[0].forward)
        x->level[0].forward->backward = x;
    else
        zsl->tail = x;
    zsl->length++;
    return x;
}

场景应用

​ 这里我们Server语言采用php, 因此代码风格为php语法:

​ 1, 数据录入

    $rank_zset_key = $rank_prefix_key.date('Y-m-d').':zset';        //定义每天排行榜的key
    $redis->zIncrBy($rank_zset_key, 1, $user_id);    //用户计数器加1

​ 2, 排行榜日榜

    $rank_zset_key = $rank_prefix_key.date('Y-m-d').':zset';
    $values = $redis->zRevRange($rank_zset_key, 0 , self::K_RANK_SIZE, true);//K_RANK_SIZE 既是排行榜的榜单长度

​ 3, 排行榜月榜

    $sta_days = [
      'prefix_key_2017-12-21:zset',
      'prefix_key_2017-12-21:zset',
      'prefix_key_2017-12-21:zset'...
    ];    
    $lastmonth_store_key = 'monthly_rank_key';
    $this->redis->zUnion($lastmonth_store_key, $sta_days);  //将每天的排行榜数据进行zUion操作, 既是合并Sorted Set
    $values = $this->redis->zRevRange($lastmonth_store_key, 0 , self::K_RANK_SIZE, true); //获取月排行榜
    
    //持久化至DB
    $db_rank = [];
    foreach ($values as $user_id => $score){
       $db_rank[$user_id] = $score;
    }
    ......

​ 但这里需要注意的是需要组成并集的各个集合的key必须是对应到redis集群中的同一个slot上，否则将会出现一个异常：CROSSSLOT Keys in request don't hash to the same slot。参考: https://redis.io/commands/cluster-keyslot

​ 所以redis提供了一种特定的标签{},这个{}内的字符串才参与计算hash slot.列如：{user}:aaa与{user}:bbb 这两个集合可以确保在同一个slot上,可以使用zunionstore求它们的并集。所以，在处理这种需要合并redis历史数据时，如果是在redis集群环境下，需要特别注意。

其他需要注意的问题

在基于redis的整个排行榜的设计过程中，我们还需要考虑的

• 排行榜key的数量：确保key的数量是可控的，可设置过期时间的，就设置明显的过期时间, 如果确实由于空间不足, 可以持久化到DB中处理
• 占用空间评估：Redis中排行榜数据内存占用情况进行评估, 防止不需要的排行榜数据长期占用内存

参考资料

http://redis.cn/

https://redis.io/commands/cluster-keyslot