Redis 数据结构选型:先访问模式,再底层编码

Redis 数据结构选型:先访问模式,再底层编码

Hello,我是小兔大白糖。 读完能按计数、对象字段、排行、基数统计选择结构,并理解 Pipeline/Lua 的原子边界。

Redis 结构选型先访问模式(计数/对象/排行/基数),再底层编码;Pipeline/Lua 才谈原子边界。

估计阅读时间:35 分钟

按访问模式选择 Redis 结构
按访问模式选择 Redis 结构 · 点击查看 SVG 原图

一句话结论是什么?

Redis 通过 SDS、ziplist/listpack、quicklist、intset、skiplist 五大底层结构在不同数据规模与访问模式下做自适应切换,配合 HyperLogLog、Bitmap、GeoHash 实现空间高效的统计与定位;在 Risk 场景下,Pipeline + Lua 的原子组合是构建高频交易频控与异地登录风控的核心武器。

1. 这是什么?概念怎么定义

1.1 五大数据类型的底层实现

Redis 对外暴露 String、Hash、List、Set、Sorted Set 五种数据类型,但底层并非直接映射到固定的数据结构,而是根据数据规模、元素大小、编码策略在运行期自动切换。理解这种 "encoding polymorphism" 是排查内存暴涨和性能退化问题的关键。

对外类型底层编码(小数据量)底层编码(大数据量)切换阈值(redis.conf 可配)
StringSDSSDS始终 SDS
Hashziplist / listpackhashtablehash-max-ziplist-entries: 512
Listquicklist (node=ziplist/listpack)quicklist (node=listpack)list-max-ziplist-size: -2
Setintsethashtableset-max-intset-entries: 512
Sorted Setziplist / listpackskiplist + hashtablezset-max-ziplist-entries: 128

SDS(Simple Dynamic String):Redis 的字符串底层实现。相比 C 原生 char* 增加了 len、alloc、flags 元数据,实现了 O(1) 长度获取、惰性释放、二进制安全(可存储图片、序列化数据等含 \0 的内容)。

ziplist / listpack:紧凑的连续内存数组。每个 entry 存储 prevlen、encoding、payload,适合小数据量、低修改频率场景。listpack 是 Redis 5.0 引入的 ziplist 替代方案,取消了 prevlen 的级联更新问题。

quicklist:双向链表,每个节点是一个 ziplist 或 listpack。通过 fill 参数控制每个节点内元素数量,通过 compress 参数对两端以外的节点进行 LZF 压缩,平衡了插入性能和内存连续性。

intset:有序的整数数组,支持 int16/int32/int64 三种编码的自动升级。当插入非整数或元素数超过阈值时,升级为 hashtable。

skiplist(跳跃表):一种随机化的多级链表,通过概率算法(p=0.25)生成节点层数,实现平均 O(log N) 的插入、删除、范围查询。Redis 的 skiplist 实现中,每个节点同时存在于 skiplist 和 hashtable 中,实现 O(1) 单点查询 + O(log N) 范围查询。

1.2 扩展数据结构

HyperLogLog:基于概率的基数统计算法,使用 12KB 固定内存即可估算 2^64 个不同元素的基数,标准误差约 0.81%。核心思想是将哈希值的二进制前缀作为 "伯努利试验" 的观测样本,通过最大连续零位数推断集合基数。

Bitmap:按位存储的字符串,每个 bit 代表一个状态(0/1)。1 亿用户的登录状态仅需约 12MB 内存。

GeoHash:将经纬度二维坐标通过 Z-order curve(Morton code)编码为一维 52 位整数,存储在 Sorted Set 中。利用 Sorted Set 的 skiplist 实现半径范围查询。

1.3 Pipeline 与 Lua 脚本

Pipeline:客户端将多条命令一次性发送到服务器,服务器批量执行后一次性返回结果。减少了 RTT(Round Trip Time),但不保证原子性。

Lua 脚本:通过 EVAL 命令将 Lua 脚本在 Redis 服务端执行。Redis 6.0 之前通过单线程模型天然保证脚本执行的原子性;Redis 6.0+ 引入多线程 IO,但脚本执行仍在主线程中串行化。

1.4 类比说明

  • SDS 像可伸缩行李箱:C 字符串是固定尺寸纸箱,装不下要换,拆封后空间也无法回收;SDS 是带刻度、可伸缩的行李箱,知道当前装了多少(len),还有多少余量(alloc),装不满时不必立即缩回,避免反复开合。
  • skiplist 像地铁快速通道:普通链表是每个站都停的慢车(O(N));skiplist 是多层隧道,高层隧道跳过更多站点,查找时先坐快车到大致区域,再换乘慢车精确到站(O(log N))。层数由随机算法决定,避免人工维护索引的复杂 rebalance。
  • ziplist/listpack 像超市货架:所有商品紧凑排列在一个货架上,找东西只需顺着数(顺序扫描),但中间插入一个新商品需要把后面的全部后移(memmove)。货架满了就换成分散仓储(hashtable),存取更快但空间不连续。

1.5 为什么需要这些结构

问题解决方案
C 字符串获取长度 O(N),缓冲区溢出SDS:O(1) 长度,自动扩容
小规模 Hash/Set 使用 hashtable 内存浪费(每个 entry overhead 约 64B)ziplist/intset:连续内存,entry overhead 约 2-10B
List 频繁插入删除需要 O(N) 移动quicklist:链表节点 + 节点内连续,平衡局部性
Sorted Set 需要同时支持按 score 排序和按 member 去重skiplist + hashtable:双索引结构
UV 统计需要 set 去重,亿级用户内存爆炸HyperLogLog:12KB 固定内存,误差 0.81%
用户行为标签(是否登录、是否绑卡)存储浪费Bitmap:1 bit / 用户
异地登录检测需要地理位置半径查询GeoHash:Sorted Set + 9 宫格范围查询

2. 核心原理是什么?

2.1 SDS 源码结构(Redis 6.0)

Redis 3.2 之后,SDS 根据字符串长度分为 5 种 header 类型(sdshdr5/8/16/32/64),用 flags 低 3 位标识类型:

struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len;        // 已用长度
    uint8_t alloc;      // 分配总长度(不含 header 和 \0)
    unsigned char flags;// 低 3 位标识 header 类型
    char buf[];         // 柔性数组,实际数据
};

空间预分配策略:

  • 修改后 len < 1MB:分配 2 * len 空间(即预留 len 的 free 空间)
  • 修改后 len >= 1MB:分配 len + 1MB 空间

惰性空间释放:sdstrim 等操作不立即回收内存,而是记录 free 空间,供后续复用;需要真正释放时调用 sdsRemoveFreeSpace。

2.2 ziplist 内存布局(Redis 4.0 及之前)

<zlbytes> <zltail> <zllen> <entry> <entry> ... <entry> <zlend>
  4B       4B       2B      ?B      ?B            ?B      1B(0xFF)

每个 entry 的结构:

<prevlen> <encoding> <content>
  1B/5B    1B/2B/5B    ?B

级联更新问题:当 entry1 长度 < 254B 时,entry2 的 prevlen 为 1B;若 entry1 插入后长度 >= 254B,entry2 的 prevlen 需扩展为 5B,导致 entry2 长度增加,可能又触发 entry3 的 prevlen 扩展——最坏 O(N^2)。

listpack 的修复:listpack 取消 prevlen,改为在每个 entry 内部存储自身长度(encoding 中包含长度信息),从尾部遍历时通过 element-total-len 倒推,彻底消除级联更新。

2.3 quicklist 结构

typedef struct quicklist {
    quicklistNode *head;
    quicklistNode *tail;
    unsigned long count;       // 总元素数
    unsigned long len;         // 节点数
    int fill;                  // 单个节点 ziplist 容量
    unsigned int compress : 16;// 两端保留未压缩节点数
} quicklist;
 
typedef struct quicklistNode {
    struct quicklistNode *prev;
    struct quicklistNode *next;
    unsigned char *zl;         // 指向 ziplist/listpack
    unsigned int sz;           // ziplist 字节数
    unsigned int count : 16;   // 节点内元素数
    unsigned int encoding : 2; // RAW/LZF
    // ...
} quicklistNode;

quicklist 的核心折中:链表保证 O(1) 的节点级插入删除,ziplist/listpack 保证节点内数据的内存连续性(CPU cache friendly)。compress 参数将中间节点压缩为 LZF 格式,两端节点保持未压缩以支持快速 LPUSH/RPOP。

2.4 skiplist 节点设计与随机层数

typedef struct zskiplistNode {
    sds ele;                    // member
    double score;               // score
    struct zskiplistNode *backward;
    struct zskiplistLevel {
        struct zskiplistNode *forward;
        unsigned long span;     // 到 forward 节点的跨度
    } level[];
} zskiplistNode;

层数生成算法(Redis 实现):

int zslRandomLevel(void) {
    int level = 1;
    while ((random() & 0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    return (level < ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}
// ZSKIPLIST_P = 0.25, MAXLEVEL = 64

期望层数 E[level] = 1 / (1 - p) = 1.33。即 75% 的节点只有 1 层,18.75% 有 2 层,以此类推。

为什么用随机层数而不是固定层数或树结构?

  • 固定层数:无法适应数据规模变化,层数过高浪费内存,过低退化为链表
  • 红黑树/AVL:虽然也是 O(log N),但范围查询(ZRANGEBYSCORE)需要中序遍历,实现复杂;skiplist 的范围查询天然按 score 顺序遍历 forward 指针,代码简洁(约 200 行 vs 数千行)
  • 随机层数:插入删除只需修改局部指针,无需全局 rebalance,实现简单且并发友好(Redis 单线程模型下无并发问题)

2.5 intset 升级机制

intset 初始为 int16_t 数组。当插入一个 int32_t 范围的整数时:

  1. 将现有所有 int16_t 扩展为 int32_t(从后往前拷贝,避免覆盖)
  2. 插入新元素
  3. 同理支持 int64_t 升级

升级是永久性的,不会降级。一旦升级为 int64_t,即使删除大值元素,仍保持 int64_t 编码。

2.6 HyperLogLog 概率原理

HyperLogLog 基于 "最大连续零位"(Max Leading Zero)观测:

  • 将每个元素哈希为一个二进制串
  • 记录哈希值中 "从左到右第一个 1 出现的位置"(即前导零个数)
  • 基数越大,出现大前导零的概率越高
  • 使用多个桶(m=2^14=16384)做随机平均,降低方差
  • 对小基数使用 Linear Counting 修正,对中等基数使用 Raw Estimate,对大基数使用偏差修正

2.7 GeoHash 编码原理

  1. 经度 [-180, 180] 二分法迭代,偶数位编码(左 0 右 1)
  2. 纬度 [-90, 90] 二分法迭代,奇数位编码(下 0 上 1)
  3. 将经纬度二进制位交叉排列(偶数位经度,奇数位纬度)
  4. Base32 编码为字符串(如 wx4g0)
  5. Redis 将 GeoHash 转为 52 位整数作为 Sorted Set 的 score

半径查询的 9 宫格策略:以目标点为中心,计算半径覆盖的 GeoHash 块。由于 GeoHash 是 Z-order 曲线,边缘误差通过计算中心点与候选点的真实 Haversine 距离做二次过滤。

2.8 Pipeline 与 Lua 的执行模型

redis data structures selection · 图 1
redis data structures selection · 图 1 · 点击查看 SVG 原图

2.9 频控系统架构图

redis data structures selection · 图 2
redis data structures selection · 图 2 · 点击查看 SVG 原图

3. 怎么用?关键代码与配置

3.1 环境准备(Spring Boot + Lettuce)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
spring:
  redis:
    host: localhost
    port: 6379
    lettuce:
      pool:
        max-active: 50
        max-idle: 20
      shutdown-timeout: 100ms
@Configuration
public class RedisConfig {
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate(
            RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
 
    @Bean
    public StringRedisTemplate stringRedisTemplate(
            RedisConnectionFactory connectionFactory) {
        return new StringRedisTemplate(connectionFactory);
    }
}

3.2 Pipeline 批量写入:用户行为日志打点

@Service
public class UserBehaviorService {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    /**
     * Pipeline 批量记录用户行为时间戳,用于后续风控关联分析。
     * 相比逐条发送,RTT 从 N * 1ms 降到 1ms + N * 本地处理时间。
     */
    public void batchRecordBehaviors(List<UserBehaviorEvent> events) {
        redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
            for (UserBehaviorEvent event : events) {
                String key = "behavior:" + event.getUserId() + ":" + event.getAction();
                byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
                byte[] scoreBytes = String.valueOf(event.getTimestamp()).getBytes();
                byte[] memberBytes = event.getDetail().getBytes(StandardCharsets.UTF_8);
 
                connection.zSetCommands().zAdd(keyBytes, event.getTimestamp(), memberBytes);
                connection.expire(keyBytes, 86400); // 24h TTL
            }
            return null;
        });
    }
}

3.3 Lua 原子频控:滑动窗口限流(风控核心)

@Service
public class RateLimitService {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    /**
     * 滑动窗口限流 Lua 脚本。
     * KEYS[1]: 频控 key(如 rate:login:userid)
     * KEYS[2]: 阻塞 key(如 block:login:userid),超限后封禁
     * ARGV[1]: 窗口大小(毫秒)
     * ARGV[2]: 窗口内最大请求数
     * ARGV[3]: 当前时间戳(毫秒,由客户端传入保证一致性)
     * ARGV[4]: 封禁时长(秒)
     *
     * 返回:0=允许,1=触发频控,2=已封禁
     */
    private static final String SLIDING_WINDOW_LUA =
        "local key = KEYS[1]\n" +
        "local blockKey = KEYS[2]\n" +
        "local window = tonumber(ARGV[1])\n" +
        "local limit = tonumber(ARGV[2])\n" +
        "local now = tonumber(ARGV[3])\n" +
        "local blockTime = tonumber(ARGV[4])\n" +
        "\n" +
        "if redis.call('exists', blockKey) == 1 then\n" +
        "    return 2\n" +
        "end\n" +
        "\n" +
        "redis.call('zremrangeByScore', key, 0, now - window)\n" +
        "local current = redis.call('zcard', key)\n" +
        "if current >= limit then\n" +
        "    redis.call('set', blockKey, 1, 'EX', blockTime)\n" +
        "    return 1\n" +
        "end\n" +
        "redis.call('zadd', key, now, now)\n" +
        "redis.call('pexpire', key, window)\n" +
        "return 0\n";
 
    private static final RedisScript<Long> SLIDING_WINDOW_SCRIPT =
        new DefaultRedisScript<>(SLIDING_WINDOW_LUA, Long.class);
 
    /**
     * 高频交易频控检查。
     * 场景:大型加密货币交易所 下单接口,用户 1 秒内超过 10 笔即触发频控并封禁 60 秒。
     */
    public RateLimitResult checkTradeRateLimit(String userId, String action) {
        String rateKey = String.format("rate:%s:%s", action, userId);
        String blockKey = String.format("block:%s:%s", action, userId);
        long now = System.currentTimeMillis();
        long windowMs = 1000;      // 1 秒窗口
        int maxRequests = 10;      // 最大 10 次
        long blockSeconds = 60;    // 封禁 60 秒
 
        Long result = redisTemplate.execute(
            SLIDING_WINDOW_SCRIPT,
            Arrays.asList(rateKey, blockKey),
            String.valueOf(windowMs),
            String.valueOf(maxRequests),
            String.valueOf(now),
            String.valueOf(blockSeconds)
        );
 
        if (result == null) result = 1L;
 
        switch (result.intValue()) {
            case 0: return RateLimitResult.ALLOW;
            case 1: return RateLimitResult.RATE_LIMITED;
            case 2: return RateLimitResult.BLOCKED;
            default: return RateLimitResult.RATE_LIMITED;
        }
    }
}
 
public enum RateLimitResult {
    ALLOW, RATE_LIMITED, BLOCKED
}

3.4 Bitmap 实现风控用户标签

@Service
public class RiskTagService {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    /**
     * 为用户打上风控标签。
     * 标签位定义(从左到右,从 0 开始):
     * bit 0: 是否登录
     * bit 1: 是否修改密码
     * bit 2: 是否绑定 2FA
     * bit 3: 是否提现
     * bit 4: 是否大额交易 (>10k USDT)
     * bit 5: 是否异地登录
     */
    public void markTag(long userId, int bitOffset) {
        String key = "risk:tag:user:" + userId;
        redisTemplate.opsForValue().setBit(key, bitOffset, true);
    }
 
    /**
     * 批量查询用户标签,用于风控规则引擎批量评估。
     */
    public Map<Long, Integer> batchGetTags(List<Long> userIds) {
        Map<Long, Integer> result = new HashMap<>();
        List<Object> pipelineResults = redisTemplate.executePipelined(
            (RedisCallback<Object>) connection -> {
                for (Long userId : userIds) {
                    String key = "risk:tag:user:" + userId;
                    connection.stringCommands().get(key.getBytes());
                }
                return null;
            }
        );
 
        for (int i = 0; i < userIds.size(); i++) {
            byte[] bytes = (byte[]) pipelineResults.get(i);
            int tagValue = (bytes == null) ? 0 : (bytes[0] & 0xFF);
            result.put(userIds.get(i), tagValue);
        }
        return result;
    }
 
    /**
     * 规则:未绑定 2FA 且发生大额交易,触发二次验证。
     */
    public boolean needSecondaryAuth(long userId) {
        String key = "risk:tag:user:" + userId;
        Boolean has2fa = redisTemplate.opsForValue().getBit(key, 2);
        Boolean largeTrade = redisTemplate.opsForValue().getBit(key, 4);
        return Boolean.FALSE.equals(has2fa) && Boolean.TRUE.equals(largeTrade);
    }
}

3.5 HyperLogLog 统计独立设备数(UV 反欺诈)

@Service
public class FraudDetectionService {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    /**
     * 记录用户设备指纹,用于检测 "一人多号" 薅羊毛。
     * 同一用户下设备数异常(如 1 天内 > 20 台不同设备)触发风控。
     */
    public void logDeviceFingerprint(long userId, String deviceId, LocalDate date) {
        String key = "hll:device:" + userId + ":" + date;
        redisTemplate.opsForHyperLogLog().add(key, deviceId);
        redisTemplate.expire(key, Duration.ofDays(7));
    }
 
    /**
     * 查询用户当日独立设备数。
     */
    public long getDistinctDeviceCount(long userId, LocalDate date) {
        String key = "hll:device:" + userId + ":" + date;
        Long count = redisTemplate.opsForHyperLogLog().size(key);
        return count != null ? count : 0L;
    }
 
    /**
     * 合并近 7 天设备指纹,检测长期异常。
     */
    public long getWeeklyDistinctDevices(long userId, List<LocalDate> dates) {
        String destKey = "hll:device:" + userId + ":week";
        String[] keys = dates.stream()
            .map(d -> "hll:device:" + userId + ":" + d)
            .toArray(String[]::new);
 
        redisTemplate.opsForHyperLogLog().union(destKey, keys);
        Long count = redisTemplate.opsForHyperLogLog().size(destKey);
        redisTemplate.delete(destKey);
        return count != null ? count : 0L;
    }
}

3.6 GeoHash 异地登录检测

@Service
public class GeoLoginDetectionService {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    /**
     * 记录用户登录时的地理位置。
     */
    public void recordLoginLocation(long userId, double longitude,
                                     double latitude, String loginTime) {
        String key = "geo:login:" + userId;
        redisTemplate.opsForGeo().add(
            key,
            new Point(longitude, latitude),
            loginTime
        );
        redisTemplate.expire(key, Duration.ofDays(30));
    }
 
    /**
     * 检测本次登录是否与上次登录位置相距过远(> 500km 且时间 < 2h)。
     */
    public boolean isSuspiciousLogin(long userId, double currentLng,
                                      double currentLat) {
        String key = "geo:login:" + userId;
 
        // 获取最近 2 次登录记录
        GeoResults<RedisGeoCommands.GeoLocation<String>> results =
            redisTemplate.opsForGeo().radius(
                key,
                new Circle(new Point(currentLng, currentLat),
                    new Distance(20000, Metrics.KILOMETERS)),
                RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
                    .sortAscending()
                    .limit(2)
                    .includeDistance()
            );
 
        if (results == null || results.getContent().size() < 2) {
            return false; // 首次登录或记录不足
        }
 
        // 最近一次记录就是当前位置本身(distance ≈ 0)
        Distance lastDistance = results.getContent().get(0).getDistance();
        Distance prevDistance = results.getContent().get(1).getDistance();
 
        // 若上一次登录与本次距离 > 500km
        return prevDistance != null &&
               prevDistance.getValue() > 500;
    }
 
    /**
     * 获取用户近 30 天登录过的所有城市(用于绘制异常轨迹)。
     */
    public List<Point> getLoginTrajectory(long userId) {
        String key = "geo:login:" + userId;
        return redisTemplate.opsForGeo().position(key,
            redisTemplate.opsForZSet().range(key, 0, -1)
                .toArray(new String[0]));
    }
}

3.7 完整 Demo:风控检查组合接口

@RestController
@RequestMapping("/api/v1/risk")
public class RiskCheckController {
 
    @Autowired
    private RateLimitService rateLimitService;
    @Autowired
    private RiskTagService riskTagService;
    @Autowired
    private FraudDetectionService fraudDetectionService;
    @Autowired
    private GeoLoginDetectionService geoLoginDetectionService;
 
    @PostMapping("/pre-trade-check")
    public ResponseEntity<RiskCheckResult> preTradeCheck(
            @RequestHeader("X-User-Id") long userId,
            @RequestHeader("X-Device-Id") String deviceId,
            @RequestBody TradeRequest request) {
 
        // 1. 频控检查
        RateLimitResult rateResult = rateLimitService
            .checkTradeRateLimit(String.valueOf(userId), "trade");
        if (rateResult != RateLimitResult.ALLOW) {
            return ResponseEntity.status(429)
                .body(new RiskCheckResult(false, "RATE_LIMITED"));
        }
 
        // 2. 异地登录检测
        boolean suspiciousGeo = geoLoginDetectionService
            .isSuspiciousLogin(userId, request.getLng(), request.getLat());
        if (suspiciousGeo) {
            riskTagService.markTag(userId, 5); // bit 5 = 异地登录
        }
 
        // 3. 设备指纹反欺诈
        fraudDetectionService.logDeviceFingerprint(
            userId, deviceId, LocalDate.now());
        long deviceCount = fraudDetectionService
            .getDistinctDeviceCount(userId, LocalDate.now());
        if (deviceCount > 20) {
            return ResponseEntity.ok(
                new RiskCheckResult(false, "TOO_MANY_DEVICES"));
        }
 
        // 4. 二次认证检查
        if (riskTagService.needSecondaryAuth(userId)) {
            return ResponseEntity.ok(
                new RiskCheckResult(false, "2FA_REQUIRED"));
        }
 
        return ResponseEntity.ok(new RiskCheckResult(true, "PASS"));
    }
}
 
@Data
@AllArgsConstructor
class RiskCheckResult {
    private boolean allowed;
    private String reason;
}
 
@Data
class TradeRequest {
    private String symbol;
    private double amount;
    private double lng;
    private double lat;
}

4. 业界怎么做?

4.1 阿里巴巴 / 蚂蚁集团:Bitmap 构建万亿级用户行为标签体系

场景:支付宝需要实时判断用户是否满足营销活动的参与条件(如 "近 30 天有消费 + 已实名 + 未参与过同类活动")。若用 Hash/Set 存储,10 亿用户 * 100 个标签,内存成本不可接受。

方案:

  • 每个标签对应一个 Bitmap,key 为 tag:{tag_id}:{date_partition},offset 为用户 ID
  • 使用 BITOP 做标签交集运算。例如 "近 7 天活跃用户 AND 实名用户 AND NOT 黑名单用户" 直接通过 BITOP AND + BITOP NOT 在 Redis 端计算
  • 夜间预计算常用组合标签,将结果写入新 Bitmap

踩坑:

  • Bitmap 膨胀:早期使用自增 user_id 作为 offset,某业务 user_id 达到 90 亿(非连续),Bitmap 理论上需要 90 亿 bit ≈ 11GB,实际只有 1 千万活跃用户。后改为 "映射表" 方案:将活跃用户连续编号,维护 user_id -> compact_id 映射,Bitmap 降至 1MB 级别
  • Big Key 问题:单 Bitmap 过大导致持久化时 fork 写时复制内存翻倍,引发 OOM。后将 Bitmap 按 1000 万用户分片(tag:1:shard_0 ~ tag:1:shard_N),查询时客户端聚合
  • 分片聚合与 CPU 平衡:BITOP 的 CPU 开销较高,阿里内部将常用 BITOP 操作下沉到自研的 Tair(Redis 分支)的 RoaringBitmap 模块,将内存和计算效率再提升 10 倍

4.2 美团:Pipeline + Lua 实现库存扣减与防超卖

场景:美团外卖的秒杀活动(如 "1 元抢奶茶"),高峰期 QPS 10 万+,需要保证库存扣减的原子性且不能超卖。

方案:

  • 库存数据存储在 Redis Hash:stock:{sku_id} -> { "total": 10000, "sold": 0 }
  • 使用 Lua 脚本保证 "查询库存 -> 判断余量 -> 扣减 -> 记录用户已抢" 的原子性
  • 使用 Pipeline 批量预热热点 SKU 库存到本地缓存,减少 Redis 压力

核心 Lua 脚本:

local stockKey = KEYS[1]
local userKey = KEYS[2]
local userId = ARGV[1]
 
if redis.call('sismember', userKey, userId) == 1 then
    return -1  -- 已抢购
end
 
local stock = tonumber(redis.call('hget', stockKey, 'total'))
local sold = tonumber(redis.call('hget', stockKey, 'sold'))
if sold >= stock then
    return 0   -- 库存不足
end
 
redis.call('hincrby', stockKey, 'sold', 1)
redis.call('sadd', userKey, userId)
redis.call('expire', userKey, 86400)
return 1       -- 抢购成功

踩坑:

  • Lua 脚本超时导致主库阻塞:早期脚本中误加了复杂循环(遍历大量 key),Redis 单线程执行 5 秒+,导致整个 Redis 实例拒绝服务。后引入 "脚本复杂度审查" + lua-time-limit 告警,脚本仅允许 O(1) 操作
  • 热点 Key 问题:单个 SKU 的 Hash 成为热点,单机 Redis CPU 打满。后改为 "分段库存":stock:{sku_id}:0 ~ stock:{sku_id}:99,每个分段独立扣减,客户端轮询分段;库存回收时通过异步任务合并
  • Pipeline 误用导致数据不一致:有工程师在 Pipeline 中混用 MULTI/EXEC 和 Lua,Pipeline 批量发送的 MULTI 与 Lua 脚本的强原子性语义冲突,部分命令被其他客户端穿插执行。后规定 "原子操作统一用 Lua,批量非原子操作用 Pipeline,两者不混用"

4.3 字节跳动:HyperLogLog 实时 UV 与反作弊

场景:抖音短视频需要实时统计每个视频的播放量(PV)和独立观众数(UV),用于推荐算法排序和创作者结算。亿级日活下,精确 Set 去重内存不可承受。

方案:

  • PV 用 Redis String INCR,天然原子
  • UV 用 Redis HyperLogLog,PFADD vid:{video_id}:uv {user_id}
  • 实时查询 PFCOUNT vid:{video_id}:uv,误差在 0.5% 以内,满足业务需求
  • 反作弊场景:检测 "刷量工作室" 通过少量设备反复观看。对同一 WiFi/设备下的账号群,计算其 HyperLogLog 的 "重叠度"(通过合并后 UV 与单账号 UV 之和的差异判断),异常则标记

踩坑:

  • HyperLogLog 合并后精度下降:当视频 UV 从 0 增长到 10 亿,PFCOUNT 误差绝对值可达数百万。对于创作者结算等场景,字节在达到 100 万 UV 后切换为 "精确抽样"(布隆过滤器 + 1% 抽样对账),HyperLogLog 仅用于推荐排序
  • HyperLogLog 不支持删除:误操作 PFDEL 不存在,对于 "取消点赞后 UV 修正" 无法实现。后改为点赞用 HyperLogLog,取消点赞时仅做逻辑标记,日终对账时从离线数仓修正

5. 业务场景怎么对照?

5.1 风控 / Risk 场景应用矩阵

风控场景Redis 数据结构实现方式关键参数
高频交易频控Sorted Set + Lua滑动窗口,ZREMRANGEBYSCORE + ZCARDwindow=1s, limit=10
用户行为标签Bitmap每个用户 1 Byte,8 个标签位标签位定义文档化
独立设备数 / UVHyperLogLogPFADD device_id,PFCOUNT 查询误差 0.81%,不精确去重
异地登录检测Geo + Sorted SetGEOADD + GEORADIUS半径 500km + 时间窗口 2h
黑名单 / 白名单SetSISMEMBER O(1) 判断定期全量同步 + 增量更新
登录失败次数String (INCR) + EXPIRE计数器 + 自动过期5 次失败封禁 30 分钟
设备指纹关联HashHSET device:{id} ip, ua, geoTTL 7 天
实时聚合指标Sorted SetZINCRBY 计数,ZREVRANGE 取 TopN按时间分片避免 Big Key

5.2 常见误区 vs 正确做法

误区 1:Hash 的 field 太多时仍使用 ziplist/listpack

  • ❌ 错误:不调整 hash-max-ziplist-entries,当 Hash 有 1 万个 field 时仍用 ziplist,导致查找复杂度 O(N)(ziplist 是线性扫描)
  • ✅ 正确:监控 redis-cli --bigkeys,对超过 512 fields 的 Hash,确保已转为 hashtable;对于大 Hash,考虑按 field 前缀拆分为多个 Hash Key

误区 2:使用 KEYS 命令做模式匹配

  • ❌ 错误:KEYS risk:tag:user:* 在拥有百万 Key 的生产环境执行,导致单线程 Redis 阻塞数秒
  • ✅ 正确:使用 SCAN 0 MATCH risk:tag:user:* COUNT 1000 分批迭代;或在写入时维护一个 Set/索引 Key

误区 3:Pipeline 中混用事务和 Lua,误以为 Pipeline 是原子的

  • ❌ 错误:将 MULTI; INCR; EXPIRE; EXEC 和 Lua 脚本放在同一个 Pipeline 中发送,认为 "一起发就是一起执行"
  • ✅ 正确:Pipeline 仅减少 RTT,命令在服务端仍可能与其他客户端穿插执行。需要原子性时统一使用 Lua 脚本(或 Redis 事务,但事务不支持条件判断)

误区 4:Bitmap 使用非连续 ID 作为 offset

  • ❌ 错误:用户 ID 是 UUID hash 后的 64 位整数,直接作为 offset,Bitmap 分配 2^64 bit 内存
  • ✅ 正确:建立 "活跃 ID -> 连续编号" 映射,或改用 RoaringBitmap(Redis 4.0+ 模块),或按 ID 范围分片

误区 5:Lua 脚本中执行耗时操作

  • ❌ 错误:在 Lua 中 for i=1,100000 do redis.call('get', 'key:' .. i) end,单线程阻塞 Redis
  • ✅ 正确:Lua 脚本仅包含 O(1) 操作,循环次数严格限制(建议 < 100);大数据量操作在客户端分批 Pipeline 处理

误区 6:忽视 GeoHash 的边缘精度问题

  • ❌ 错误:直接用 GEORADIUS 结果作为风控判定,未做 Haversine 距离二次校验,导致相邻 GeoHash 块内误判
  • ✅ 正确:GEORADIUS 返回候选集后,在应用层用 Haversine 公式精确计算距离,消除 GeoHash Z-order 曲线的边缘误差

5.3 选型建议

需求推荐方案不推荐方案原因
精确计数(不能超卖)String INCR / LuaHyperLogLogHLL 是概率算法,不精确
亿级 UV 统计HyperLogLogSetSet 内存不可承受
范围查询 + 排序Sorted Set (skiplist)Hash + 客户端排序服务端排序效率更高
频繁头尾插入List (quicklist)Array / ziplist 单 keyquicklist 的链表结构保证 O(1)
布尔标签(是否登录)BitmapHash/SetBitmap 1 bit / 用户,极致压缩
地理位置半径查询Geo (Sorted Set)自建索引GeoHash 已优化 9 宫格查询
需要条件判断的原子操作Lua 脚本MULTI/EXEC事务不支持条件分支
批量非原子写Pipeline逐条发送Pipeline 减少 RTT,吞吐量提升 10x+

6. 高频问题怎么答?

Q1: Redis 的 Hash 底层,ziplist 何时会转为 hashtable?反过来会降级吗?

当同时满足以下任一条件时,ziplist 编码的 Hash 会转为 hashtable:

  1. 元素个数超过 hash-max-ziplist-entries(默认 512)
  2. 单个元素长度超过 hash-max-ziplist-value(默认 64 字节)

不会降级。一旦升级为 hashtable,即使后续删除元素至阈值以下,编码也不会回退到 ziplist。这是 Redis 的设计权衡——避免编码在阈值附近反复震荡(thundering herd 问题)。如果需要降级,必须手动删除 Key 后重建。

Q2: skiplist 为什么用随机层数而不是固定层数或平衡树?

三个核心原因:

  1. 实现简单:skiplist 的插入删除只需修改局部指针,代码约 200 行;红黑树需处理旋转和颜色翻转,代码数千行,bug 概率更高
  2. 范围查询友好:skiplist 的 forward 指针天然按 score 顺序排列,ZRANGEBYSCORE 只需沿最底层遍历;树结构需中序遍历,实现复杂
  3. 无需 rebalance:随机层数的期望高度为 O(log N),概率上保证平衡;固定层数无法适应数据规模变化

Redis 选 skiplist 而非 B+ 树,还因为 skiplist 的内存开销更可控(每个节点额外 N*8 字节指针,N 为层数),且有序集合同时需要 member 去重(hashtable)和 score 排序(skiplist),双索引结构配合更自然。

Q3: Bitmap 的内存如何估算?用户 ID 不连续怎么办?

Bitmap 的内存 = (max_offset / 8) + 1 Byte。若 offset = 1 亿,内存 ≈ 12MB。

用户 ID 不连续的三种解决方案:

  1. 映射表:维护 user_id -> compact_id 映射(如用 Redis Hash 或本地缓存),仅活跃用户分配连续 ID
  2. 分片 Bitmap:按 ID 范围分片(如每 1000 万一个 Bitmap),查询时定位到对应分片
  3. RoaringBitmap:使用 Redis 模块或客户端库(Java 的 RoaringBitmap),用 Container(Array/Run/Bitmap)自适应存储,稀疏数据效率远高于原生 Bitmap

Q4: Pipeline 和事务(MULTI/EXEC)有什么区别?

特性PipelineMULTI/EXEC
原子性否,命令可能与其他客户端穿插是,命令队列串行执行
回滚无无(EXEC 后部分失败不处理)
条件判断不支持不支持(需配合 WATCH 乐观锁)
用途批量非原子操作,减少 RTT保证一组命令原子执行
异常处理逐条返回结果,需客户端判断EXEC 返回数组,包含每条结果

需要 "原子性 + 条件判断" 时,应使用 Lua 脚本,而非 Pipeline 或事务。

Q5: Lua 脚本在 Redis 6.0+ 多线程模型下还是原子的吗?

是的。Redis 6.0 引入的多线程仅用于 网络 IO 读写(多线程解析请求、序列化响应),命令执行仍在主线程中单线程串行化。Lua 脚本的执行逻辑完全在主线程中完成,因此天然原子。

但需注意:若 Lua 脚本执行时间过长(如 lua-time-limit 默认 5 秒),Redis 会触发 SCRIPT KILL 或 SHUTDOWN NOSAVE 保护机制。在集群模式下,Lua 脚本访问的 Key 必须落在同一 Slot(通过 Hash Tag 如 {user}:123 控制)。

Q6: quicklist 的压缩策略 list-compress-depth 如何工作?

list-compress-depth 控制 quicklist 两端保留多少个未压缩节点,中间节点用 LZF 压缩:

  • 0:不压缩(默认)
  • 1:首尾各 1 个节点不压缩,中间压缩
  • 2:首尾各 2 个节点不压缩,中间压缩

原理:List 的头尾操作(LPUSH/RPOP/LRANGE 前几个元素)最频繁,两端节点保持未压缩可降低延迟;中间节点访问频率低,压缩节省内存。这是一种经典的 "温度数据分层" 策略。

Q7: GeoHash 的查询为什么需要 9 宫格?

GeoHash 将地球划分为矩形网格,但 Z-order 曲线的特性导致:目标点附近的点不一定在相邻的 GeoHash 编码上(存在 "突变边界")。例如,经度 180 和 -180 在物理上相邻,但 GeoHash 编码完全不同。

因此 GEORADIUS 会:

  1. 计算圆心所在 GeoHash 块
  2. 获取周围 8 个相邻块(共 9 个)
  3. 在每个块对应的 Sorted Set score 范围内查询
  4. 对结果做 Haversine 精确距离过滤(消除矩形覆盖的边角误差)

Q8: intset 升级到 hashtable 后还能降级回 intset 吗?

不能。与 ziplist -> hashtable 类似,intset -> hashtable 是单向升级。一旦升级,即使删除所有元素,编码也不会回退。如果需要降级,只能删除 Key 后重新创建。这也是 Redis 避免编码震荡的设计。

Q9: 在风控场景中,Redis 数据丢失(如主从切换)对频控有什么影响?

Redis 默认的异步复制 + 非持久化配置下,主从切换可能导致少量数据丢失。对于频控场景:

  • Acceptable:丢失少量计数,导致用户多请求 1-2 次才被限流,风险较低
  • Mitigation:
    1. 使用 Redis AOF appendfsync always(性能下降约 50%,需评估)
    2. 在应用层做 "漏桶补偿":Redis 限流后,本地内存再维护一个短周期漏桶
    3. 对极高风控等级(如提现),使用 Redlock 或写入持久化存储(如 etcd / ZooKeeper)做二次校验

Q10: 为什么 Redis 5.0 引入 listpack 替代 ziplist?listpack 如何解决级联更新?

ziplist 的 entry 存储 prevlen(前一个 entry 的长度),当前一个 entry 长度从 253 变为 254 时,prevlen 编码从 1B 扩展为 5B,导致当前 entry 长度增加,可能触发连锁反应。

listpack 的解决方案:

  • 取消 prevlen,改为 element-total-len(当前 entry 的总长度)
  • 从尾部遍历时,通过 element-total-len 向前跳转:当前位置 - element-total-len = 前一个 entry 的起始位置
  • 插入/删除只影响当前 entry 自身的 element-total-len,不会级联影响其他 entry

listpack 的 trade-off:从头部遍历时仍需要顺序解析(无法像 ziplist 那样通过 prevlen 倒跳),但 Redis 的 List 操作以 LPUSH/RPOP 为主,尾部遍历场景更多,因此 listpack 是更优选择。