
Hello,我是小兔大白糖。 读完能按计数、对象字段、排行、基数统计选择结构,并理解 Pipeline/Lua 的原子边界。
Redis 结构选型先访问模式(计数/对象/排行/基数),再底层编码;Pipeline/Lua 才谈原子边界。
估计阅读时间:35 分钟
一句话结论是什么?
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 可配) |
|---|---|---|---|
| String | SDS | SDS | 始终 SDS |
| Hash | ziplist / listpack | hashtable | hash-max-ziplist-entries: 512 |
| List | quicklist (node=ziplist/listpack) | quicklist (node=listpack) | list-max-ziplist-size: -2 |
| Set | intset | hashtable | set-max-intset-entries: 512 |
| Sorted Set | ziplist / listpack | skiplist + hashtable | zset-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 范围的整数时:
- 将现有所有 int16_t 扩展为 int32_t(从后往前拷贝,避免覆盖)
- 插入新元素
- 同理支持 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 编码原理
- 经度 [-180, 180] 二分法迭代,偶数位编码(左 0 右 1)
- 纬度 [-90, 90] 二分法迭代,奇数位编码(下 0 上 1)
- 将经纬度二进制位交叉排列(偶数位经度,奇数位纬度)
- Base32 编码为字符串(如
wx4g0) - Redis 将 GeoHash 转为 52 位整数作为 Sorted Set 的 score
半径查询的 9 宫格策略:以目标点为中心,计算半径覆盖的 GeoHash 块。由于 GeoHash 是 Z-order 曲线,边缘误差通过计算中心点与候选点的真实 Haversine 距离做二次过滤。
2.8 Pipeline 与 Lua 的执行模型
2.9 频控系统架构图
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 + ZCARD | window=1s, limit=10 |
| 用户行为标签 | Bitmap | 每个用户 1 Byte,8 个标签位 | 标签位定义文档化 |
| 独立设备数 / UV | HyperLogLog | PFADD device_id,PFCOUNT 查询 | 误差 0.81%,不精确去重 |
| 异地登录检测 | Geo + Sorted Set | GEOADD + GEORADIUS | 半径 500km + 时间窗口 2h |
| 黑名单 / 白名单 | Set | SISMEMBER O(1) 判断 | 定期全量同步 + 增量更新 |
| 登录失败次数 | String (INCR) + EXPIRE | 计数器 + 自动过期 | 5 次失败封禁 30 分钟 |
| 设备指纹关联 | Hash | HSET device:{id} ip, ua, geo | TTL 7 天 |
| 实时聚合指标 | Sorted Set | ZINCRBY 计数,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 / Lua | HyperLogLog | HLL 是概率算法,不精确 |
| 亿级 UV 统计 | HyperLogLog | Set | Set 内存不可承受 |
| 范围查询 + 排序 | Sorted Set (skiplist) | Hash + 客户端排序 | 服务端排序效率更高 |
| 频繁头尾插入 | List (quicklist) | Array / ziplist 单 key | quicklist 的链表结构保证 O(1) |
| 布尔标签(是否登录) | Bitmap | Hash/Set | Bitmap 1 bit / 用户,极致压缩 |
| 地理位置半径查询 | Geo (Sorted Set) | 自建索引 | GeoHash 已优化 9 宫格查询 |
| 需要条件判断的原子操作 | Lua 脚本 | MULTI/EXEC | 事务不支持条件分支 |
| 批量非原子写 | Pipeline | 逐条发送 | Pipeline 减少 RTT,吞吐量提升 10x+ |
6. 高频问题怎么答?
Q1: Redis 的 Hash 底层,ziplist 何时会转为 hashtable?反过来会降级吗?
当同时满足以下任一条件时,ziplist 编码的 Hash 会转为 hashtable:
- 元素个数超过
hash-max-ziplist-entries(默认 512) - 单个元素长度超过
hash-max-ziplist-value(默认 64 字节)
不会降级。一旦升级为 hashtable,即使后续删除元素至阈值以下,编码也不会回退到 ziplist。这是 Redis 的设计权衡——避免编码在阈值附近反复震荡(thundering herd 问题)。如果需要降级,必须手动删除 Key 后重建。
Q2: skiplist 为什么用随机层数而不是固定层数或平衡树?
三个核心原因:
- 实现简单:skiplist 的插入删除只需修改局部指针,代码约 200 行;红黑树需处理旋转和颜色翻转,代码数千行,bug 概率更高
- 范围查询友好:skiplist 的 forward 指针天然按 score 顺序排列,
ZRANGEBYSCORE只需沿最底层遍历;树结构需中序遍历,实现复杂 - 无需 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 不连续的三种解决方案:
- 映射表:维护
user_id -> compact_id映射(如用 Redis Hash 或本地缓存),仅活跃用户分配连续 ID - 分片 Bitmap:按 ID 范围分片(如每 1000 万一个 Bitmap),查询时定位到对应分片
- RoaringBitmap:使用 Redis 模块或客户端库(Java 的 RoaringBitmap),用 Container(Array/Run/Bitmap)自适应存储,稀疏数据效率远高于原生 Bitmap
Q4: Pipeline 和事务(MULTI/EXEC)有什么区别?
| 特性 | Pipeline | MULTI/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 会:
- 计算圆心所在 GeoHash 块
- 获取周围 8 个相邻块(共 9 个)
- 在每个块对应的 Sorted Set score 范围内查询
- 对结果做 Haversine 精确距离过滤(消除矩形覆盖的边角误差)
Q8: intset 升级到 hashtable 后还能降级回 intset 吗?
不能。与 ziplist -> hashtable 类似,intset -> hashtable 是单向升级。一旦升级,即使删除所有元素,编码也不会回退。如果需要降级,只能删除 Key 后重新创建。这也是 Redis 避免编码震荡的设计。
Q9: 在风控场景中,Redis 数据丢失(如主从切换)对频控有什么影响?
Redis 默认的异步复制 + 非持久化配置下,主从切换可能导致少量数据丢失。对于频控场景:
- Acceptable:丢失少量计数,导致用户多请求 1-2 次才被限流,风险较低
- Mitigation:
- 使用 Redis AOF
appendfsync always(性能下降约 50%,需评估) - 在应用层做 "漏桶补偿":Redis 限流后,本地内存再维护一个短周期漏桶
- 对极高风控等级(如提现),使用 Redlock 或写入持久化存储(如 etcd / ZooKeeper)做二次校验
- 使用 Redis AOF
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 是更优选择。