Redis源码探究系列—有序集合 ZSet 的底层实现解析

最新推荐文章于 2026-06-23 23:25:52 发布
原创 最新推荐文章于 2026-06-23 23:25:52 发布 · 508 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#redis

在前面的章节中，我们深入剖析了跳表（skiplist）的实现原理，并探讨了Redis为何选择跳表而非红黑树作为有序数据结构的核心。跳表以其简洁的实现、优秀的平均性能和良好的缓存局部性，成为Redis的关键基础设施。

但在实际工程中，Redis并非无脑使用跳表——对于小规模数据集，跳表的指针开销反而成为累赘。本文将揭示ZSet如何通过双编码自适应机制，在不同数据规模下自动选择最优存储方式，实现内存与性能的完美平衡。

一、ZSet是什么？

有序集合（Sorted Set，简称 ZSet）是 Redis 最强大的数据结构之一。它同时具备：

  • 集合性：元素不重复
  • 有序性：每个元素关联一个score，按score排序
  • 可查性：按元素查score、按score查范围、按排名查范围
ZADD myzset 1 "one" 2 "two" 3 "three"
ZRANGE myzset 0 -1           → "one" "two" "three"
ZRANGEBYSCORE myzset 1 2     → "one" "two"
ZRANK myzset "three"         → 2
ZSCORE myzset "two"          → 2

为了同时高效支持这些操作，Redis为ZSet设计了双层编码机制。

二、ZSet的两种编码

2.1 编码常量

// server.h
#define OBJ_ENCODING_ZIPLIST 5   // 压缩列表编码
#define OBJ_ENCODING_SKIPLIST 7  // 跳表编码

2.2 编码选择规则

元素数量 <= 128 且 每个元素长度 <= 64 字节  →  ZIPLIST
否则                                    →  SKIPLIST

// server.h:804-807
#define OBJ_ZSET_MAX_ZIPLIST_ENTRIES 128
#define OBJ_ZSET_MAX_ZIPLIST_VALUE 64

这两个阈值可以通过 Redis 配置文件中的 zset-max-ziplist-entries 和 zset-max-ziplist-value 参数进行调整。例如：

zset-max-ziplist-entries 128
zset-max-ziplist-value 64

分别控制ziplist编码下ZSet最大元素数量和单个元素最大长度，超过任一阈值就会自动升级为skiplist编码。

2.3 编码转换触发

ZIPLIST → SKIPLIST:
  - 元素数量超过 128
  - 任意元素长度超过 64 字节

SKIPLIST → ZIPLIST:
  - 不会自动转回（即使元素被大量删除）

编码转换在zsetAdd函数中触发，发生在每次添加元素时。

三、ZIPLIST编码

3.1 存储结构

ZIPLIST编码下，ZSet的元素以紧凑的方式存储在一个连续的内存块中：
在这里插入图片描述

  • 每个元素占两个entry：一个存member（字符串），一个存score（浮点数的字符串表示）
  • 元素按score从小到大排列
  • score相同时按member的字典序排列

3.2 为什么用ziplist？

优势说明
内存紧凑连续内存，无指针开销，每个元素节省16-32字节
缓存友好连续内存，CPU缓存命中率高
适合小数据量元素少时遍历开销可忽略，内存优势明显

代价是所有操作都是O(n)，但n <= 128时，O(n)的实际耗时远小于跳表O(log n)的指针跳转开销。

3.3 ziplist相关API

Redis为ziplist编码封装了一组zzl*函数，与skiplist编码的zsl*函数对称：

// t_zset.c — ziplist 编码操作

// 读取 score
double zzlGetScore(unsigned char *sptr);

// 查找元素
unsigned char *zzlFind(unsigned char *zl, sds ele, double *score);

// 插入元素
unsigned char *zzlInsert(unsigned char *zl, sds ele, double score);

// 删除元素
unsigned char *zzlDelete(unsigned char *zl, unsigned char *eptr);

// 范围删除
unsigned char *zzlDeleteRangeByScore(unsigned char *zl, zrangespec *range, unsigned long *deleted);
unsigned char *zzlDeleteRangeByRank(unsigned char *zl, unsigned int start, unsigned int end, unsigned long *deleted);

// 范围查询
unsigned char *zzlFirstInRange(unsigned char *zl, zrangespec *range);
unsigned char *zzlLastInRange(unsigned char *zl, zrangespec *range);

// 遍历
void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr);
void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr);

// 元素数
unsigned int zzlLength(unsigned char *zl);   // = ziplistLen(zl) / 2

3.4 zzlFind —— 按元素查找

// t_zset.c:1001-1018
unsigned char *zzlFind(unsigned char *zl, sds ele, double *score) {
    // eptr指向当前遍历到的member entry，sptr指向其后面的score entry
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;

    while (eptr != NULL) {
        sptr = ziplistNext(zl,eptr); // sptr指向eptr后面的score entry
        serverAssert(sptr != NULL);  // 保证score entry存在

        // 比较当前member entry内容与目标ele是否相等
        if (ziplistCompare(eptr,(unsigned char*)ele,sdslen(ele))) {
            // 如果需要，解析score entry并返回
            if (score != NULL) *score = zzlGetScore(sptr);
            return eptr; // 返回找到的member entry指针
        }

        // 跳到下一个member entry（即当前score entry的下一个）
        eptr = ziplistNext(zl,sptr);
    }
    // 未找到，返回NULL
    return NULL;
}

从头遍历ziplist，逐个比较member。找到后，下一个entry就是score。

3.5 zzlInsert —— 有序插入

// t_zset.c:1056-1087
// 在ziplist中有序插入一个(member, score)对，保持score升序，score相同按member字典序。
unsigned char *zzlInsert(unsigned char *zl, sds ele, double score) {
    // eptr指向当前遍历到的member entry，sptr指向其后面的score entry
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;
    double s;

    while (eptr != NULL) {
        sptr = ziplistNext(zl,eptr); // sptr指向eptr后面的score entry
        serverAssert(sptr != NULL);  // 保证score entry存在
        s = zzlGetScore(sptr);       // 解析当前元素的score

        // 如果当前score大于待插入score，找到插入点
        if (s > score) {
            zl = zzlInsertAt(zl,eptr,ele,score);
            break;
        } else if (s == score) {
            // score相等时，按member字典序插入
            if (zzlCompareElements(eptr,(unsigned char*)ele,sdslen(ele)) > 0) {
                zl = zzlInsertAt(zl,eptr,ele,score);
                break;
            }
        }

        // 继续遍历下一个member entry
        eptr = ziplistNext(zl,sptr);
    }

    // 如果遍历到末尾还未插入，则插入到ziplist尾部
    if (eptr == NULL)
        zl = zzlInsertAt(zl,NULL,ele,score);
    return zl;
}

遍历找到插入位置（score从小到大，score相同时按member字典序），然后调用zzlInsertAt在该位置插入两个entry。

3.6 zzlDelete —— 删除元素

// t_zset.c:1022-1029
unsigned char *zzlDelete(unsigned char *zl, unsigned char *eptr) {
    unsigned char *p = eptr;
    zl = ziplistDelete(zl,&p);  // 删除 member entry
    zl = ziplistDelete(zl,&p);  // 删除 score entry
    return zl;
}

连续调用两次ziplistDelete，删除member和score两个entry。

四、SKIPLIST编码

4.1 双数据结构

SKIPLIST编码下，ZSet使用两个数据结构协同工作：

// server.h:818-822
typedef struct zset {
    dict *dict;         // 哈希表，key为member，value为指向score的指针
    zskiplist *zsl;     // 跳表，按score有序存储所有元素
} zset;

ZSet的底层结构，包含两种数据结构：

  • dict：用于按member快速查找score，支持O(1)的ZSCORE等操作
  • zskiplist：用于按score有序存储元素，支持范围查询和有序遍历

两者共享同一组元素，数据只存一份
在这里插入图片描述

4.2 为什么需要dict？

跳表只支持按score查找，但ZSCORE命令需要按member查score。如果只用跳表：

ZSCORE myzset "two"
→ 需要遍历整个跳表找 member="two"，O(n)

加了dict后：

ZSCORE myzset "two"
→ dictFind(dict, "two")，O(1)

dict和zskiplist共享同一组元素：dict的val指向跳表节点的score，跳表节点的ele就是member的SDS。数据只存一份，两个结构各自提供高效的访问路径。

4.3 操作映射

命令dict 操作zskiplist 操作
ZADDdictAdd / dictReplacezslInsert
ZREMdictDeletezslDelete
ZSCOREdictFind—
ZRANK—zslGetRank
ZRANGE—遍历 Level 0
ZRANGEBYSCORE—zslFirstInRange + 遍历
ZREVRANGE—tail + backward 遍历
ZINCRBYdictFind + 更新zslUpdateScore / zslInsert
ZCARD—zsl->length
ZCOUNT—zslFirstInRange + 计数

五、zsetAdd —— ZSet的核心写入函数

zsetAdd是所有ZSet写入命令（ZADD、ZINCRBY）的底层实现，它处理了编码判断、编码转换、增删改等所有逻辑。

// t_zset.c:1278-1437
int zsetAdd(robj *zobj, double score, sds ele, int *flags, double *newscore) {

5.1 编码判断与转换

    // 如果当前zset对象采用ziplist编码
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *eptr;

        // 查找元素是否已存在
        if ((eptr = zzlFind(zobj->ptr,ele,NULL)) != NULL) {
            // 元素已存在，需更新score（具体逻辑见下文）
            ...
        } else {
            // 元素不存在，插入新元素
            zobj->ptr = zzlInsert(zobj->ptr,ele,score);

            // 检查是否需要转换为skiplist编码：
            // 条件1：元素数量超过阈值（128）
            if (zzlLength(zobj->ptr) > server.zset_max_ziplist_entries)
                zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
            // 条件2：任意元素长度超过阈值（64字节）
            if (sdslen(ele) > server.zset_max_ziplist_value)
                zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
        }
    }

转换条件（两个独立条件，满足任一即转换）：

  1. 元素数量超过zset_max_ziplist_entries（默认128）
  2. 任意元素长度超过zset_max_ziplist_value（默认64字节）

5.2 ziplist编码下的更新

        // 查找元素是否已存在（eptr指向member entry，curscore为当前score）
        if ((eptr = zzlFind(zobj->ptr,ele,&curscore)) != NULL) {
            // 元素已存在
            if (flags & ZADD_INCR) {
                // INCR模式，累加score
                score += curscore;
                if (isnan(score)) { // 检查累加后是否为NaN
                    *flags = ZADD_NAN;
                    return 0;
                }
                if (newscore) *newscore = score; // 返回新score
            }

            // 只有score发生变化才需要更新
            if (score != curscore) {
                // ziplist不支持原地修改，需先删后插
                zobj->ptr = zzlDelete(zobj->ptr,eptr); // 删除原有元素
                zobj->ptr = zzlInsert(zobj->ptr,ele,score); // 插入新score
                *flags |= ZADD_UPDATED;
            }
        }

ziplist不支持原地修改score（因为修改可能改变score的字符串长度，导致ziplist重分配），所以采用先删后插的策略。

5.3 skiplist编码下的更新

    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
        zset *zs = zobj->ptr;
        zskiplistNode *znode;
        dictEntry *de;

        // 先在dict中查找元素是否存在
        de = dictFind(zs->dict,ele);
        if (de != NULL) {
            // 元素已存在
            double curscore = *(double*)dictGetVal(de); // 当前score

            if (flags & ZADD_INCR) {
                // INCR模式，累加score
                score += curscore;
                if (isnan(score)) { // 检查累加后是否为NaN
                    *flags = ZADD_NAN;
                    return 0;
                }
                if (newscore) *newscore = score; // 返回新score
            }

            // 只有score发生变化才需要更新
            if (score != curscore) {
                // 跳表支持原地更新score（如位置变化则删除再插入）
                znode = zslUpdateScore(zs->zsl,curscore,ele,score); // 更新score
                dictGetVal(de) = &znode->score; // dict同步指向新score
                *flags |= ZADD_UPDATED;
            }
        } else {
            // 元素不存在，插入新元素
            znode = zslInsert(zs->zsl,score,ele); // 跳表插入
            dictAdd(zs->dict,ele,&znode->score);  // dict同步
            if (newscore) *newscore = score;
        }
    }

dict的val存储的是 &znode->score，即指向跳表节点score字段的地址，这样 ZSCORE 查询时可以 O(1) 直接获取分数，无需额外存储一份数据。当需要更新分数时，通过调用 zslUpdateScore，如果节点位置不变则直接修改分数，否则会先删除再插入新的节点。每次分数变动后，dict的val都会同步更新为新节点的score地址，确保dict和zskiplist始终保持一致。

六、编码转换 —— zsetConvert

// t_zset.c:1170-1215
/*
 * zsetConvert: 编码转换函数，将zset对象从ziplist编码转换为skiplist编码
 * 只实现ziplist→skiplist的自动转换，反向仅用于特殊场景
 */
void zsetConvert(robj *zobj, int encoding) {
    zset *zs;
    zskiplistNode *node, *next;
    sds ele;
    double score;

    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *zl = zobj->ptr;
        unsigned char *eptr, *sptr;
        unsigned char *vstr;
        unsigned int vlen;
        long long vlong;

        // 1. 分配新zset结构（dict+zskiplist）
        zs = zmalloc(sizeof(*zs));
        zs->dict = dictCreate(&zsetDictType,NULL);
        zs->zsl = zslCreate();

        // 2. 遍历ziplist，逐对(member, score)迁移到新结构
        eptr = ziplistIndex(zl,0);
        while (eptr != NULL) {
            sptr = ziplistNext(zl,eptr); // sptr指向score entry
            serverAssert(sptr != NULL);
            serverAssert(ziplistGet(eptr,&vstr,&vlen,&vlong)); // 解析member

            if (vstr == NULL)
                ele = sdsfromlonglong(vlong); // 数值型member
            else
                ele = sdsnewlen((char*)vstr,vlen); // 字符串型member

            score = zzlGetScore(sptr); // 解析score
            node = zslInsert(zs->zsl,score,ele); // 跳表插入
            dictAdd(zs->dict,ele,&node->score);  // dict同步

            eptr = ziplistNext(zl,sptr); // 下一个member entry
        }

        // 3. 释放旧ziplist，更新zobj指针和编码
        zfree(zl);
        zobj->ptr = zs;
        zobj->encoding = OBJ_ENCODING_SKIPLIST;

    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
        // ... 反向转换（用于 DEBUG 等场景）
    }
}

转换过程如下：

  1. 创建zset结构（dict + zskiplist）
  2. 遍历ziplist的所有member-score对
  3. 对每个元素，同时插入dict和zslInsert到zskiplist
  4. 释放旧ziplist
  5. 更新zobj->ptr和zobj->encoding

为什么没有自动的SKIPLIST → ZIPLIST回转？ 因为元素被大量删除后，ziplist的内存优势不再显著（ziplist的删除需要内存搬移），且频繁的编码转换本身也有开销。Redis选择只在编码升级时转换，不回退。

七、两种编码的性能对比

7.1 操作复杂度

操作ZIPLISTSKIPLIST
ZSCOREO(n)O(1)（dict）
ZADDO(n)O(log n)
ZREMO(n)O(log n) + O(1)
ZRANKO(n)O(log n)
ZRANGEO(m)O(log n + m)
ZRANGEBYSCOREO(n)O(log n + m)
ZCARDO(1)O(1)

7.2 实际性能

元素数量ZIPLIST内存SKIPLIST内存ZSCORE耗时比
10~200B~2KBZIPLIST 更快
64~1.5KB~12KB接近
128~3KB~24KBSKIPLIST 更快
10000—~2MBSKIPLIST 远快

约100个元素时，SKIPLIST的O(log n)开始超过ZIPLIST的O(n)（因为ZIPLIST的O(n)常数极小，缓存友好）。Redis将阈值设为128，偏向内存节省。

7.3 内存对比

每个元素的内存开销：

编码每元素开销总计（128元素）
ZIPLISTentry header + member + entry header + score~3 KB
SKIPLISTzskiplistNode(约64B) + dictEntry(约32B) + SDS~24 KB

ZIPLIST的内存优势约8倍。对于大量小规模ZSet（如用户标签、排行榜），这种差距在总量上非常可观。

八、ZSet命令的完整数据流

8.1 ZADD命令

在这里插入图片描述

8.2 ZRANGEBYSCORE / ZSCORE命令

在这里插入图片描述

九、ziplist与skiplist的统一API

Redis通过zsetAdd、zsetDel、zsetGetScore等函数屏蔽了底层编码差异，上层命令无需关心当前使用哪种编码：

// 统一API
int zsetAdd(robj *zobj, double score, sds ele, int *flags, double *newscore);
int zsetDel(robj *zobj, sds ele);
double zsetGetScore(robj *zobj, sds ele);
unsigned long zsetLength(robj *zobj);
long zsetRank(robj *zobj, sds ele, int reverse);

这种设计使得新增命令时只需调用统一API即可，无需关心底层编码细节。

ZSet的底层实现通过自动选择ziplist或skiplist编码、dict与跳表双结构协作、数据共享、单向不可逆转换、统一API封装和可调阈值配置，完美体现了Redis的核心设计原则：在简单中追求极致的效率——小数据时极致节省内存，大数据时保证高效操作，两者无缝切换。

在下一章节中，我们将深入剖析Redis内存紧凑结构的演进历程，从ziplist的经典设计到listpack的终极方案，全面揭示Redis如何在极致节省内存的同时保持合理的性能。这些压缩结构不仅服务于ZSet，更是List、Hash、Stream等多种数据类型的内存优化基石。

redis zset 内部的实现原理
热门推荐
李意成的博客
07-04 2万+
Redis对象 Redis对象由redisObject结构体表示。 1 2 3 4 5 6 7 typedef struct redisObject { unsigned type:4; // 对象的类型，包括 /* Object types */ unsigned e...
Redis 7.x 系列【10】数据类型之有序集合（ZSet）
记录知识、锤炼自我
06-27 1842
ZSet是一种有序集合类型，可以存储不重复的元素，并且给每个元素赋予一个double类型的排序权重值。
Redis从精通到入门——数据类型Zset实现源码详解
“实用”是软件压倒一切的要素
02-06 2170
Zset简介，Zset常用操作，应用场景，Zset实现，源码阅读，Zset—ziplist实现，图解Zset—ziplist，Zset—字典(dict) + 跳表(zskiplist)实现，源码阅读，图解zskiplist
限流之redis 有序集合（zset）实现滑动窗口
yzh_1346983557的博客
05-30 5984
需求：同一用户1分钟内登录失败次数超过3次，页面添加验证码登录验证，即限流的思想。常见的限流算法：固定窗口计数器；滑动窗口计数器；漏桶；令牌桶。本篇选择的滑动窗口计数器。
Redis - 主从集群脑裂：数据丢失的隐藏杀手
小工匠
06-16 494
摘要： Redis主从集群中的脑裂问题会导致数据丢失，表现为客户端写入原主库的数据在切换后被全量同步清除。脑裂常由主库假故障（如资源争抢或实例阻塞）引发，此时哨兵触发切换但原主库仍在接收写入。通过配置min-slaves-to-write和min-slaves-max-lang参数，可限制主库在从库同步异常时拒绝写入，减少数据丢失风险。建议参数设置需结合从库数量和哨兵超时时间，并注意该方案无法完全避免数据丢失。本质上是Redis异步复制在性能与一致性间的权衡，关键运维措施包括避免主库资源竞争和监控阻塞情况。
先更库还是先删缓存？数据库与 Redis 双写一致性全对比
2603_94941239的博客
06-22 231
先更库，后删缓存。不是因为它完美，而是因为它的最坏情况只是"短暂不一致"，而反过来的最坏情况是"永久脏数据"。能用 MQ 异步删，就别在主链路上同步删。能让 Canal 干的活，就别让业务代码扛。双写一致性的本质不是选顺序，而是承认一定会不一致，然后设计一个能自愈的机制。
从零实现一个分布式锁：Redis与Zookeeper
2502_94055806的博客
06-22 222
│ 客户端A │ ──────────────────────────────────────→ │ Zookeeper │。│ 客户端A │ ───────────────────────────────────────→ │ Redis │。│ 客户端A │ ───────────────────────────────────────→ │ Redis │。printf("\n--- Zookeeper分布式锁 ---\n");printf("--- Redis分布式锁 ---\n");
Redis 数据结构
土司先生的博客
06-22 249
redis 的 string , list 队列，Set 集，的数据结构讲解
Redis SET NX EX 使用说明
bsklhao的博客
06-22 212
在 Redis 中，SET NX EX是一种将设置键值对、条件判断和过期时间结合在一起的原子操作。
Redis 从入门到实战
qq_72113648的博客
06-20 252
上面命令后面加上 --raw 参数即可正常显示中文redis-cli连接成功后，会看到提示符。如果设置了Redis密码，则需要使用AUTH命令手动验证密码让我们来练习几个最基础的通用命令，来管理 Redis 中的 Key。- 设置一个键值对- 获取一个键的值- 查找所有符合给定模式的 Key（- 判断一个 Key 是否存在- 返回 Key 所存储的值的类型- 为 Key 设置过期时间（单位：秒）- 删除一个或多个 Key。
[036][缓存模块]基于 Redis 自定义缓存锁的设计与实现
2403_86882821的博客
06-21 260
本文介绍了一种基于Redis的轻量级分布式锁组件的设计与实现，通过注解+AOP+Lua脚本的方式解决高并发场景下的缓存击穿、重复计算和资源竞争问题。该组件提供固定租期和自动续期两种模式，支持SpEL动态Key生成，确保操作的原子性和安全性。核心实现包含自定义注解@RedisLockable、AOP切面、Lua脚本加解锁逻辑以及自动续期机制。优点包括声明式编程、灵活Key设计、双模式选择和原子操作，但也存在线程泄露风险、缺乏重试机制等不足，建议改用ScheduledExecutorService并增加取消回调
Redis 的IO
菜鸟的博客
06-17 234
为了避免用户导致冲突甚至内核崩溃，用户应用与内核时分离的：用户空间只执行受限的命令，而且不能直接调用系统资源，必须通过内核提供的内核空间可以执行特权命令，调用一切系统资源Linux系统为了提高IO效率，会在用户空间和内核空间都加入缓冲区:写数据时，要把用户缓冲数据拷贝到内核缓冲区，然后写入设备读数据时，要从设备读取数据到内核缓冲区，然后拷贝到用户缓冲区顾名思义，非阻塞IO的recvfrom操作会立即返回结果而不是阻塞用户进程。
Redis...2
dllxhcjla的博客
06-23 194
1.id是会展示给用户的，如果id的规律性太强会让用户观察出一定的信息2.受表单数据的限制：订单量是和容易积累的，在多年的运营下，订单量很可能超过了单表所能存储的最大数量，此时开始新的一个表来存储的时候，自增的ID就会出现重复的情况前三十一位为时间戳，记录下单时间，以秒为单位序列号：秒内的计数器，支持每秒产生2的三十二次方个id确保唯一性的方法：不同时间（不在同一秒）的id依靠时间戳来决定相同时间（在同一秒）的id依靠序列号来分辨变化的key，1.因为如果时间的key都是同一个，那么，同一秒内的时间戳（包括
Spring AI 实战指南（八）：Spring AI + Redis + PGVector + DeepSeek 企业级性能优化与高并发架构设计
2601_94975336的博客
06-17 170
更高级方案。自动总结用户：Java开发准备面试目标大厂100条聊天记录80%以上当你的项目发展到这一步时，你已经不仅仅是在做一个 Spring AI Demo，而是在构建一个真正可上线的 AI 平台。ChatClient↓↓RAG↓↓↓Agent↓MCP↓性能优化↓企业级AI架构。
Go 企业级工程能力实战（8）：Redis 不只是缓存——分布式限流、在线心跳与分布式锁从零实现
binbin3828的博客
06-21 146
Redis 在场景Redis 能力关键命令解决什么问题分布式限流原子计数器INCREXPIRE多实例共享限流计数在线心跳带 TTL 的状态存储SETEX高频写入 + 自动过期 + 批量查询分布式锁（扩展）互斥锁SETNXEXPIRE+ Lua 脚本多实例下资源互斥（库存扣减/定时任务去重）接口抽象Limiter接口让内存和 Redis 两种实现无缝切换，调用方完全不感知优雅降级：Redis 不可用时自动回退到内存方案，服务不崩溃，只是限流精度下降做减法。
正规 API 中转站怎么判断？个人和企业如何挑选稳定又相对省心的 AI API 接口（附 Dify、Cursor 配置与报错排查）
weixin_54442559的博客
06-21 490
如果只给一个最朴素的判断标准，我会说：稳定不是零报错，而是报错好查、切换好换、成本好算。便宜也不是单价最低，而是你把重试、超时、人工排查和团队协作都算进去之后，总成本仍然可控。个人开发者更适合先看接入门槛和错误提示是否清楚，先把脚本、Dify、Cursor 这些常见入口跑通。团队用户更应该看权限、日志、预算和统一管理。企业用户则优先看合规、审计、分权和备选方案，而不是只盯着价格。我自己的经验是，真正好用的 AI API 接口，不是让你完全不报错，而是让你知道错在哪、改哪、怎么切。
Redis 过期删除三大策略详解
2609_95039045的博客
06-22 207
策略本质定时删除用 CPU 换内存，太贵，不用惰性删除用内存换 CPU，太懒，单用会漏定期删除抽样巡逻，可控可调，是主力Redis 组合拳定期巡逻 + 惰性把关 + Fast 应急 = 性能与内存的最优解Redis 的过期删除，不是某一种策略的胜利，而是两种策略互相补短的艺术。理解这一点，才算真正读懂了 Redis 的内存管理哲学。
Docker搭建Elasticsearch+Redis+Logstash+Filebeat日志分析系统完整指南
曼陀罗的博客
06-17 263
3节点的Elasticsearch集群提供高可用存储Logstash负责日志采集和处理Filebeat作为轻量级日志采集器Kibana提供可视化分析界面Redis/Kafka作为消息缓冲队列这套系统可支持大规模日志采集和分析场景，并可根据实际需求进行横向扩展。在实际生产环境中，建议根据日志量动态调整各组件资源配置，并建立完善的监控告警体系。
redis和RedisTemplate 、Redisson的区别
最新发布
fang0604631023的博客
06-23 73
Redis、RedisTemplate 和 Redisson 并不是相互替代的关系，而是、以及之间的关系。
搜狗电话面试：网络、MySQL、Redis、锁和 Linux 命令一次全扫
TechPioneer_lp的博客
06-16 134
这篇搜狗后端电话面经展现了典型的基础知识快扫模式，覆盖网络协议（TCP握手/挥手、粘包）、数据库（MySQL隔离级别、索引）、Redis缓存问题、进程通信、Linux命令等核心考点，最后以两数之和算法题收尾。这种面试重点考察候选人知识体系的完整性和口头表达能力，特别容易暴露基础薄弱环节。面经价值在于揭示了后端岗位的基础能力门槛：网络、数据库、操作系统等知识必须形成系统认知，才能通过电话面试的即时问答考验。准备此类面试需重点强化各模块的逻辑串联和场景化表达，而不仅是碎片化知识点记忆。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值