面试深挖:黑白名单与流控

通识对照:限流与熔断:容量闸门、故障隔离与多级漏斗

面试深挖:黑白名单与流控

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


TL;DR:黑白名单与频控限流是风控系统的"第一道闸门"——黑名单(Blacklist)是终身禁入令,白名单(Whitelist)是 VIP 免检通道,灰名单(Graylist)是观察期缓刑,而频控限流(Rate Limiting)则是防止暴力冲撞的"减速带"。四者协同构成了从"快速拒绝"到"精细限流"的多层防御体系,核心挑战在于如何在毫秒级延迟内完成分级判定,同时保证分布式环境下的计数原子性和策略一致性。


1. 概念定义(是什么)

1.1 黑白灰名单的三色模型

风控中的名单体系不是非黑即白的二元对立,而是一个三色光谱:

名单类型英文决策特征有效期典型场景
白名单Whitelist直接放行,跳过风控校验长期/永久内部员工、KYC 认证通过的高信用用户、已知合规机构
灰名单Graylist增强观察,提高 scrutiny 级别短期(分钟~天)新注册设备、异常登录后恢复、可疑但证据不足的用户
黑名单Blacklist直接阻断/强挑战可配置(小时~永久)已知欺诈地址、制裁名单(OFAC/UN)、被盗账户、恶意 IP

关键区分:

  • 黑名单 ≠ 简单拒绝:在支付/交易场景中,直接拒绝可能打草惊蛇(fraudster 会立即切换身份)。因此黑名单往往触发"静默拒绝"(shadow ban)——返回成功但后端拒绝执行,或要求额外的 KYC/人脸验证。
  • 白名单 ≠ 完全信任:白名单只是"降低校验强度",而非"免除审计"。合规要求下,大额交易即便白名单用户也需要上报。

1.2 频控限流的本质

频控(Rate Control)是对时间维度上的行为密度进行限制,防止:

  • 暴力破解:每秒 1000 次登录尝试
  • 羊毛党扫货:毫秒级并发下单
  • DDoS 层攻击:API 接口被刷爆
  • 资金外逃:短时间内大额集中提现

四大经典算法对比:

算法核心思想优点缺点适用场景
固定窗口计数器每个时间窗口内固定配额实现简单窗口边界突发(double the rate)粗粒度限制,不推荐核心链路
滑动窗口计数器统计最近 N 秒内的请求数精度高,无边界问题内存/计算开销大(需记录每个请求)精准限流(如发送验证码)
滑动窗口日志记录每个请求时间戳,滑动过滤最精确存储成本高低 QPS 高价值接口
令牌桶(Token Bucket)以固定速率产生令牌,请求需消耗令牌允许突发,平滑输出瞬时突发可能超限额API 网关、带宽控制
漏桶(Leaky Bucket)请求入桶,以固定速率漏出绝对平滑,无突发无法应对合法突发流量整形(traffic shaping)

1.3 类比理解

类比:机场安检体系

  • 白名单 = 机组人员/机场员工专用通道(Known Crew Member,免检快速通过)
  • 灰名单 = SSSS 标记旅客(Secondary Security Screening Selection,需要脱鞋、开包、全身扫描,额外审查但不拒绝登机)
  • 黑名单 = 禁飞名单(No-Fly List,直接拒绝登机,甚至触发执法)
  • 频控限流 = 安检通道人数限制(每个通道每分钟最多过 30 人,防止拥堵和漏检——对应系统防止过载和漏判)
  • 阶梯限流 = 根据机场拥挤度动态开放通道(平时 2 条,节假日 8 条,红色预警时只开 1 条并提高检查标准)

2. 核心原理与图解

2.1 多级名单决策架构

interview blacklist ratecontrol · 图 1
interview blacklist ratecontrol · 图 1 · 点击查看 SVG 原图

分层设计哲学:

  • L1 层:纯本地内存,无网络 I/O,负责"明显 friend"和"明显 foe"的快速判定。命中率需 > 90%,否则 L2 压力爆炸。
  • L2 层:Redis 集中存储,解决多节点一致性。灰名单和频控计数器在此层实现。
  • L3 层:复杂规则引擎和模型评分,异步或同步执行,取决于延迟 SLA。

2.2 灰名单状态机(Graylist State Machine)

灰名单不是静态标签,而是一个有状态、有生命周期的过渡区域:

interview blacklist ratecontrol · 图 2
interview blacklist ratecontrol · 图 2 · 点击查看 SVG 原图

灰名单的数学表达:

灰名单得分 G(t) = α·BehaviorScore(t) + β·VelocityRisk(t) + γ·NetworkRisk(t) + δ·DeviceRisk(t)

其中:
- α + β + γ + δ = 1.0(权重和为 1)
- BehaviorScore: 用户历史行为偏离度(z-score)
- VelocityRisk: 时间密度异常(如 10 分钟内 5 次改绑手机)
- NetworkRisk: IP/ASN/代理/VPN 风险评分
- DeviceRisk: 设备指纹异常度(模拟器/云手机/改机工具)

灰名单准入阈值:G(t) ∈ [θ_gray, θ_black)
灰名单观察窗口:T_observation = f(G(t)),即得分越高观察期越长

2.3 频控算法的时序本质

2.3.1 令牌桶(Token Bucket)

interview blacklist ratecontrol · 图 3
interview blacklist ratecontrol · 图 3 · 点击查看 SVG 原图

令牌桶的关键参数:

  • Rate (r):令牌产生速率,如 100 tokens/second。决定长期平均流量。
  • Capacity (C):桶的最大容量,如 200 tokens。决定最大允许的瞬时突发(burst)。
  • 关键公式:当前可用令牌数 = min(C, 上次令牌数 + r × Δt - 已消耗)

为什么令牌桶允许突发?

想象桶是满的(C=200),之前没有请求。此时突然涌入 150 个请求,全部可以通过,因为桶里有 200 个令牌。之后令牌以 r 的速度补充。这对于正常业务是有利的(如用户批量查询),但需要配合阶梯限流防止异常大突发。

2.3.2 滑动窗口 vs 固定窗口的边界问题

时间轴(每秒限流 100):

固定窗口问题:
|-- 窗口 1 (59.5s ~ 60.5s) --|-- 窗口 2 (60.5s ~ 61.5s) --|
    100 请求在 60.4s              100 请求在 60.6s

=> 在 60.4s ~ 60.6s 这 0.2 秒内通过了 200 请求!
   实际速率 = 1000 req/s,远超限制。

滑动窗口解决:
统计最近 1 秒内的请求数,无论何时到达,
只要 60.4s ~ 61.4s 这个滑动区间内的总数 > 100 就拒绝。

2.3.3 阶梯限流(Tiered Throttling)

阶梯限流是多维度、多层级的复合限流策略,不是单一阈值:

大型加密货币交易所 提现接口阶梯限流示例:

层级 1 - 用户级(最严格):
  - 每用户每 24h 最多提现 5 次
  - 每用户单笔最低 10 USDT,最高 50,000 USDT

层级 2 - 设备级:
  - 每设备每 1h 最多登录 10 次
  - 每设备每 5min 最多发起 3 次提现请求

层级 3 - IP 级:
  - 每 IP 每 1min 最多 60 次 API 调用
  - 高风险 ASN(代理/VPN 服务商)每 IP 每 1min 最多 10 次

层级 4 - 全局级(最宽松,保护系统):
  - 全局提现 QPS 不超过 10,000
  - 全局登录 QPS 不超过 50,000

层级 5 - 地址级(AML 专项):
  - 每个目标地址每 24h 最多接收 3 笔来自不同用户的转账
  - 已知混币器地址:直接黑名单

3. 语法详解与代码示例(怎么用)

3.1 多级名单服务(Multi-Level List Service)

package com.大型加密货币交易所.risk.list;
 
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import io.lettuce.core.api.sync.RedisCommands;
import lombok.extern.slf4j.Slf4j;
 
import java.time.Duration;
import java.util.EnumMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
/**
 * 多级名单服务:全局 / 业务 / 用户三级黑白名单体系
 *
 * 设计要点:
 * 1. L1 本地缓存(Caffeine/Guava):P99 < 1ms,应对高频查询
 * 2. L2 Redis 集群:多节点一致性,支持 TTL 自动过期
 * 3. 名单变更通过 Pub/Sub 广播,本地缓存失效
 * 4. 支持白名单覆盖(用户白名单 > 业务黑名单 > 全局黑名单)
 */
@Slf4j
public class MultiLevelListService {
 
    /**
     * 名单类型枚举
     */
    public enum ListType {
        GLOBAL_BLACK,      // 全局黑名单(制裁名单、已知欺诈地址)
        GLOBAL_WHITE,      // 全局白名单(合规机构、内部系统)
        BUSINESS_BLACK,    // 业务黑名单(某业务线自定义)
        BUSINESS_WHITE,    // 业务白名单(某业务线 VIP)
        USER_BLACK,        // 用户级黑名单(人工封禁)
        USER_WHITE         // 用户级白名单(人工加白)
    }
 
    /**
     * 名单条目
     */
    public record ListEntry(
        String key,           // 名单键:userId / ip / address / deviceId
        ListType type,
        String reason,        // 列入原因:OFAC_HIT / FRAUD_CONFIRMED / MANUAL_REVIEW
        long expireAt,        // 过期时间戳(-1 表示永久)
        String operator,      // 操作人
        Map<String, String> metadata  // 扩展信息(制裁名单编号、案件号等)
    ) {}
 
    /**
     * 决策结果
     */
    public enum Decision {
        ALLOW,       // 明确放行
        BLOCK,       // 明确阻断
        CHALLENGE,   // 需要增强验证
        OBSERVE      // 进入观察模式
    }
 
    public record ListDecision(
        Decision decision,
        ListType matchedList,
        String reason,
        ListEntry entry
    ) {}
 
    // L1 本地缓存:key -> ListEntry
    private final Cache<String, ListEntry> localCache;
 
    // L2 Redis 客户端
    private final RedisCommands<String, String> redis;
 
    // 业务标识 -> Redis key 前缀映射
    private static final String REDIS_KEY_PREFIX = "risk:list:";
 
    public MultiLevelListService(RedisCommands<String, String> redis) {
        this.redis = redis;
        this.localCache = CacheBuilder.newBuilder()
            .maximumSize(100_000)
            .expireAfterWrite(Duration.ofMinutes(5))
            .recordStats()
            .build();
    }
 
    /**
     * 核心判定方法:查询一个 key 在所有层级名单中的状态
     *
     * 优先级规则(从高到低):
     * 1. 用户级白名单 > 一切(人工特批)
     * 2. 用户级黑名单(人工封禁)
     * 3. 业务级白名单
     * 4. 业务级黑名单
     * 5. 全局白名单
     * 6. 全局黑名单
     *
     * @param key     待查询的键
     * @param bizType 业务类型:WITHDRAW / LOGIN / TRADE / KYC
     * @return 决策结果
     */
    public ListDecision check(String key, String bizType) {
        // 1. L1 本地缓存查询
        ListEntry cached = localCache.getIfPresent(cacheKey(key, bizType));
        if (cached != null && !isExpired(cached)) {
            return toDecision(cached);
        }
 
        // 2. L2 Redis 查询 - 按优先级顺序
        // 2.1 用户级
        ListEntry userWhite = fetchFromRedis(redisKey(ListType.USER_WHITE, key));
        if (userWhite != null) {
            localCache.put(cacheKey(key, bizType), userWhite);
            return new ListDecision(Decision.ALLOW, ListType.USER_WHITE, "User whitelisted", userWhite);
        }
 
        ListEntry userBlack = fetchFromRedis(redisKey(ListType.USER_BLACK, key));
        if (userBlack != null) {
            localCache.put(cacheKey(key, bizType), userBlack);
            return new ListDecision(Decision.BLOCK, ListType.USER_BLACK, "User blacklisted", userBlack);
        }
 
        // 2.2 业务级(带业务线前缀)
        String bizPrefix = bizType + ":";
        ListEntry bizWhite = fetchFromRedis(redisKey(ListType.BUSINESS_WHITE, bizPrefix + key));
        if (bizWhite != null) {
            localCache.put(cacheKey(key, bizType), bizWhite);
            return new ListDecision(Decision.ALLOW, ListType.BUSINESS_WHITE, "Business whitelisted", bizWhite);
        }
 
        ListEntry bizBlack = fetchFromRedis(redisKey(ListType.BUSINESS_BLACK, bizPrefix + key));
        if (bizBlack != null) {
            localCache.put(cacheKey(key, bizType), bizBlack);
            return new ListDecision(Decision.BLOCK, ListType.BUSINESS_BLACK, "Business blacklisted", bizBlack);
        }
 
        // 2.3 全局级
        ListEntry globalWhite = fetchFromRedis(redisKey(ListType.GLOBAL_WHITE, key));
        if (globalWhite != null) {
            localCache.put(cacheKey(key, bizType), globalWhite);
            return new ListDecision(Decision.ALLOW, ListType.GLOBAL_WHITE, "Global whitelisted", globalWhite);
        }
 
        ListEntry globalBlack = fetchFromRedis(redisKey(ListType.GLOBAL_BLACK, key));
        if (globalBlack != null) {
            localCache.put(cacheKey(key, bizType), globalBlack);
            return new ListDecision(Decision.BLOCK, ListType.GLOBAL_BLACK, "Global blacklisted", globalBlack);
        }
 
        // 3. 未命中任何名单 - 默认通过,但不缓存(避免缓存穿透)
        return new ListDecision(Decision.ALLOW, null, "Not in any list", null);
    }
 
    /**
     * 批量查询 - 用于一次请求涉及多个维度(userId + IP + deviceId + address)
     */
    public Map<String, ListDecision> checkMulti(Map<String, String> dimensions, String bizType) {
        EnumMap<ListType, Set<String>> typeToKeys = new EnumMap<>(ListType.class);
        // ... 批量 Redis Pipeline 查询,减少 RTT
        return null; // simplified
    }
 
    private ListEntry fetchFromRedis(String redisKey) {
        Map<String, String> hash = redis.hgetall(redisKey);
        if (hash == null || hash.isEmpty()) {
            return null;
        }
        return new ListEntry(
            hash.get("key"),
            ListType.valueOf(hash.get("type")),
            hash.get("reason"),
            Long.parseLong(hash.get("expireAt")),
            hash.get("operator"),
            hash
        );
    }
 
    private String redisKey(ListType type, String key) {
        return REDIS_KEY_PREFIX + type.name().toLowerCase() + ":" + key;
    }
 
    private String cacheKey(String key, String bizType) {
        return bizType + ":" + key;
    }
 
    private boolean isExpired(ListEntry entry) {
        return entry.expireAt() > 0 && System.currentTimeMillis() > entry.expireAt();
    }
 
    private ListDecision toDecision(ListEntry entry) {
        return switch (entry.type()) {
            case GLOBAL_WHITE, BUSINESS_WHITE, USER_WHITE ->
                new ListDecision(Decision.ALLOW, entry.type(), "Cached whitelist", entry);
            case GLOBAL_BLACK, BUSINESS_BLACK, USER_BLACK ->
                new ListDecision(Decision.BLOCK, entry.type(), "Cached blacklist", entry);
        };
    }
}

3.2 灰名单过渡引擎(Graylist Transition Engine)

package com.大型加密货币交易所.risk.graylist;
 
import lombok.extern.slf4j.Slf4j;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
 
import java.time.Instant;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
/**
 * 灰名单过渡引擎
 *
 * 核心职责:
 * 1. 维护观察对象的状态机(Observation -> Gray -> Black/White)
 * 2. 基于行为评分自动晋升/降级
 * 3. 观察期窗口动态计算
 * 4. 与 Rule Engine 和 ML Model 联动
 */
@Slf4j
public class GraylistTransitionEngine {
 
    private final Jedis jedis;
    private final RiskScoringService scoringService;
    private final MultiLevelListService listService;
    private final ScheduledExecutorService scheduler;
 
    // 灰名单评分阈值
    private static final double THETA_OBSERVE = 0.3;   // 进入观察
    private static final double THETA_GRAY = 0.6;      // 进入灰名单
    private static final double THETA_BLACK = 0.9;     // 进入黑名单
    private static final double THETA_RECOVER = 0.2;   // 恢复正常
 
    public GraylistTransitionEngine(Jedis jedis,
                                     RiskScoringService scoringService,
                                     MultiLevelListService listService) {
        this.jedis = jedis;
        this.scoringService = scoringService;
        this.listService = listService;
        this.scheduler = Executors.newScheduledThreadPool(4);
 
        // 启动灰名单扫描任务:每 30 秒扫描一次即将过期的观察对象
        scheduler.scheduleWithFixedDelay(this::scanAndTransition, 10, 30, TimeUnit.SECONDS);
    }
 
    /**
     * 上报一次行为事件,可能触发状态迁移
     *
     * @param userId    用户 ID
     * @param eventType 事件类型:LOGIN / WITHDRAW / TRADE / DEVICE_CHANGE
     * @param features  行为特征
     */
    public void onBehaviorEvent(String userId, String eventType, Map<String, Double> features) {
        // 1. 计算当前综合风险评分
        double score = scoringService.calculateBehaviorScore(userId, eventType, features);
 
        // 2. 获取当前状态
        GrayState currentState = getCurrentState(userId);
 
        // 3. 状态机转换
        GrayState newState = transition(currentState, score, userId);
 
        if (newState != currentState) {
            log.info("Graylist transition: userId={}, {} -> {}, score={}",
                userId, currentState, newState, score);
            applyTransition(userId, currentState, newState, score);
        }
 
        // 4. 无论是否迁移,都更新评分历史(用于趋势分析)
        recordScoreHistory(userId, score);
    }
 
    /**
     * 状态机转换逻辑
     */
    private GrayState transition(GrayState current, double score, String userId) {
        return switch (current) {
            case NORMAL -> {
                if (score >= THETA_OBSERVE) {
                    yield GrayState.OBSERVED;
                }
                yield GrayState.NORMAL;
            }
            case OBSERVED -> {
                if (score >= THETA_BLACK) {
                    yield GrayState.BLACKLISTED;
                } else if (score >= THETA_GRAY) {
                    yield GrayState.GRAYLISTED;
                } else if (score < THETA_RECOVER) {
                    yield GrayState.NORMAL;
                }
                yield GrayState.OBSERVED;
            }
            case GRAYLISTED -> {
                if (score >= THETA_BLACK) {
                    yield GrayState.BLACKLISTED;
                } else if (score < THETA_RECOVER) {
                    // 需要连续多次低于阈值才真正恢复,防止震荡
                    if (isConsistentlyLow(userId, 3)) {
                        yield GrayState.WHITELISTED;  // 或者 NORMAL
                    }
                }
                yield GrayState.GRAYLISTED;
            }
            case BLACKLISTED -> {
                // 黑名单通常人工解除,极少自动恢复
                if (score < THETA_RECOVER && isAppealApproved(userId)) {
                    yield GrayState.GRAYLISTED;  // 先回灰名单观察
                }
                yield GrayState.BLACKLISTED;
            }
            case WHITELISTED -> {
                if (score >= THETA_OBSERVE) {
                    // 白名单用户出现异常,降级到观察
                    yield GrayState.OBSERVED;
                }
                yield GrayState.WHITELISTED;
            }
        };
    }
 
    /**
     * 执行状态迁移的后继动作
     */
    private void applyTransition(String userId, GrayState from, GrayState to, double score) {
        String redisKey = "risk:gray:" + userId;
 
        Pipeline pipe = jedis.pipelined();
 
        // 更新状态
        pipe.hset(redisKey, "state", to.name());
        pipe.hset(redisKey, "lastTransition", String.valueOf(Instant.now().getEpochSecond()));
        pipe.hset(redisKey, "score", String.valueOf(score));
 
        // 设置 TTL:观察期和灰名单有过期时间
        long ttl = calculateObservationWindow(to, score);
        if (ttl > 0) {
            pipe.expire(redisKey, ttl);
        }
 
        // 执行名单操作
        switch (to) {
            case BLACKLISTED -> {
                // 同步写入黑名单,并触发风控告警
                pipe.sadd("risk:blacklist:pending", userId);
                // 发送告警消息到 Kafka/SNS
                publishAlert(userId, "AUTO_BLACKLIST", "Score reached threshold: " + score);
            }
            case GRAYLISTED -> {
                // 应用灰名单限制策略
                pipe.hset(redisKey, "withdrawLimit", "0.5");      // 提现限额降至 50%
                pipe.hset(redisKey, "require2FA", "true");        // 强制 2FA
                pipe.hset(redisKey, "delayWithdraw", "86400");    // 提现延迟 24h
                pipe.hset(redisKey, "scrutinyLevel", "HIGH");     // 提高 scrutiny
            }
            case NORMAL, WHITELISTED -> {
                // 清理限制
                pipe.del(redisKey + ":restrictions");
            }
            case OBSERVED -> {
                pipe.hset(redisKey, "scrutinyLevel", "MEDIUM");
            }
        }
 
        pipe.sync();
    }
 
    /**
     * 动态计算观察窗口:分数越高,观察期越长
     */
    private long calculateObservationWindow(GrayState state, double score) {
        return switch (state) {
            case OBSERVED -> (long) (3600 * (1 + score));           // 1~2 小时
            case GRAYLISTED -> (long) (86400 * (1 + score * 2));    // 1~3 天
            case BLACKLISTED -> -1;                                  // 永久
            case WHITELISTED -> 2592000;                             // 30 天有效期
            case NORMAL -> 0;
        };
    }
 
    /**
     * 定时扫描:处理即将过期的灰名单用户,决定是否续期或释放
     */
    private void scanAndTransition() {
        // 实际实现:扫描 Redis 中即将过期的 key,或者通过 Sorted Set 按时间排序
        // 这里简化示意
        log.debug("Scanning graylist for transitions...");
    }
 
    private GrayState getCurrentState(String userId) {
        String state = jedis.hget("risk:gray:" + userId, "state");
        return state != null ? GrayState.valueOf(state) : GrayState.NORMAL;
    }
 
    private boolean isConsistentlyLow(String userId, int consecutiveTimes) {
        // 检查最近 consecutiveTimes 次评分是否都低于恢复阈值
        // 从 Redis 的 ZSET 中读取评分历史
        return false; // simplified
    }
 
    private boolean isAppealApproved(String userId) {
        // 查询申诉系统状态
        return false; // simplified
    }
 
    private void recordScoreHistory(String userId, double score) {
        String key = "risk:gray:history:" + userId;
        long now = Instant.now().getEpochSecond();
        jedis.zadd(key, now, now + ":" + score);
        jedis.expire(key, 604800); // 保留 7 天
    }
 
    private void publishAlert(String userId, String type, String message) {
        // 发送到 Kafka / SNS / PagerDuty
    }
 
    public enum GrayState {
        NORMAL,       // 正常
        OBSERVED,     // 观察中
        GRAYLISTED,   // 灰名单
        BLACKLISTED,  // 黑名单
        WHITELISTED   // 白名单
    }
 
    public interface RiskScoringService {
        double calculateBehaviorScore(String userId, String eventType, Map<String, Double> features);
    }
}

3.3 Redis + Lua 原子频控实现

package com.大型加密货币交易所.risk.ratelimit;
 
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
 
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.stream.Collectors;
 
/**
 * 基于 Redis + Lua 的原子频控实现
 *
 * 为什么必须用 Lua?
 * 1. Redis 的 GET + INCR + EXPIRE 不是原子的,并发下会超限
 * 2. Lua 脚本在 Redis 单线程中执行,天然保证原子性
 * 3. 减少网络 RTT(一次请求完成判断+计数+过期设置)
 */
public class RedisLuaRateLimiter {
 
    private final JedisPool jedisPool;
 
    // 1. 滑动窗口限流 Lua 脚本
    private final String slidingWindowScript;
 
    // 2. 令牌桶限流 Lua 脚本
    private final String tokenBucketScript;
 
    // 3. 漏桶限流 Lua 脚本
    private final String leakyBucketScript;
 
    public RedisLuaRateLimiter(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
        this.slidingWindowScript = loadScript("sliding_window.lua");
        this.tokenBucketScript = loadScript("token_bucket.lua");
        this.leakyBucketScript = loadScript("leaky_bucket.lua");
    }
 
    private String loadScript(String resourceName) {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(
                    getClass().getResourceAsStream("/lua/" + resourceName),
                    StandardCharsets.UTF_8))) {
            return reader.lines().collect(Collectors.joining("\n"));
        } catch (Exception e) {
            throw new RuntimeException("Failed to load Lua script: " + resourceName, e);
        }
    }
 
    /**
     * 滑动窗口限流
     *
     * @param key      限流 key:user:123:api:withdraw
     * @param limit    窗口内最大请求数
     * @param windowMs 窗口大小(毫秒)
     * @return true = 允许通过,false = 被限流
     */
    public boolean slidingWindowAllow(String key, int limit, long windowMs) {
        try (Jedis jedis = jedisPool.getResource()) {
            long now = System.currentTimeMillis();
            // 清除窗口外的旧记录,添加当前请求,返回当前窗口内数量
            Object result = jedis.eval(slidingWindowScript,
                Collections.singletonList(key),
                Collections.singletonList(String.valueOf(limit)),
                Collections.singletonList(String.valueOf(windowMs)),
                Collections.singletonList(String.valueOf(now))
            );
            // Lua 返回 1 表示允许,0 表示拒绝
            return Long.valueOf(1L).equals(result);
        }
    }
 
    /**
     * 令牌桶限流
     *
     * @param key      限流 key
     * @param capacity 桶容量(最大突发)
     * @param rate     令牌产生速率(每秒)
     * @param requested 本次请求需要的令牌数(默认为 1)
     * @return true = 允许通过
     */
    public boolean tokenBucketAllow(String key, int capacity, double rate, int requested) {
        try (Jedis jedis = jedisPool.getResource()) {
            long now = System.currentTimeMillis();
            Object result = jedis.eval(tokenBucketScript,
                Collections.singletonList(key),
                Collections.singletonList(String.valueOf(capacity)),
                Collections.singletonList(String.valueOf(rate)),
                Collections.singletonList(String.valueOf(requested)),
                Collections.singletonList(String.valueOf(now))
            );
            return Long.valueOf(1L).equals(result);
        }
    }
 
    /**
     * 漏桶限流(严格平滑)
     */
    public boolean leakyBucketAllow(String key, int capacity, double leakRate) {
        try (Jedis jedis = jedisPool.getResource()) {
            long now = System.currentTimeMillis();
            Object result = jedis.eval(leakyBucketScript,
                Collections.singletonList(key),
                Collections.singletonList(String.valueOf(capacity)),
                Collections.singletonList(String.valueOf(leakRate)),
                Collections.singletonList(String.valueOf(now))
            );
            return Long.valueOf(1L).equals(result);
        }
    }
}

Lua 脚本:滑动窗口(sliding_window.lua)

-- KEYS[1]: 限流 key
-- ARGV[1]: limit (最大请求数)
-- ARGV[2]: window (窗口大小,毫秒)
-- ARGV[3]: now (当前时间戳,毫秒)
 
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local windowStart = now - window
 
-- 1. 移除窗口外的旧记录
redis.call('ZREMRANGEBYSCORE', key, 0, windowStart)
 
-- 2. 获取当前窗口内的请求数
local current = redis.call('ZCARD', key)
 
-- 3. 判断是否超限
if current >= limit then
    return 0  -- 拒绝
end
 
-- 4. 添加当前请求,设置 key 过期时间(窗口的 2 倍,防止边缘丢失)
redis.call('ZADD', key, now, now .. ':' .. redis.call('INCR', key .. ':seq'))
redis.call('PEXPIRE', key, window * 2)
 
return 1  -- 允许

Lua 脚本:令牌桶(token_bucket.lua)

-- KEYS[1]: 限流 key
-- ARGV[1]: capacity (桶容量)
-- ARGV[2]: rate (每秒产生令牌数)
-- ARGV[3]: requested (本次请求令牌数)
-- ARGV[4]: now (当前时间戳,毫秒)
 
local key = KEYS[1]
local capacity = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local requested = tonumber(ARGV[3])
local now = tonumber(ARGV[4])
 
-- 读取当前状态
local tokens = redis.call('GET', key .. ':tokens')
local lastTime = redis.call('GET', key .. ':last_time')
 
if tokens == false then
    tokens = capacity
    lastTime = now
else
    tokens = tonumber(tokens)
    lastTime = tonumber(lastTime)
 
    -- 计算时间差产生的令牌
    local delta = (now - lastTime) / 1000.0
    local added = delta * rate
    tokens = math.min(capacity, tokens + added)
end
 
-- 检查是否足够
if tokens < requested then
    return 0  -- 拒绝
end
 
-- 消耗令牌,更新状态
tokens = tokens - requested
redis.call('SET', key .. ':tokens', tokens)
redis.call('SET', key .. ':last_time', now)
redis.call('PEXPIRE', key .. ':tokens', 60000)
redis.call('PEXPIRE', key .. ':last_time', 60000)
 
return 1  -- 允许

3.4 阶梯限流组件(Tiered Rate Limiter)

package com.大型加密货币交易所.risk.ratelimit;
 
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.google.common.util.concurrent.RateLimiter;
import lombok.extern.slf4j.Slf4j;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * 阶梯限流组件:多级、多维度的复合限流策略
 *
 * 设计层级(从严格到宽松):
 * 1. 用户级 (User)     - 最严格,保护单个用户不被盗刷
 * 2. 设备级 (Device)   - 防止设备农场/模拟器
 * 3. IP 级   (IP)      - 防止单 IP 批量攻击
 * 4. 业务级 (Business) - 保护具体业务接口
 * 5. 全局级 (Global)   - 保护整个系统不过载
 *
 * 实现混合:
 * - 单机维度:Guava RateLimiter(令牌桶)
 * - 分布式维度:Redis + Lua(滑动窗口/令牌桶)
 * - 自适应维度:Sentinel(动态规则 + 热点参数)
 */
@Slf4j
public class TieredRateLimiter {
 
    private final RedisLuaRateLimiter redisLimiter;
    private final Map<String, RateLimiter> localLimiters = new ConcurrentHashMap<>();
 
    // Sentinel 规则缓存
    private volatile List<FlowRule> sentinelRules = new ArrayList<>();
 
    public TieredRateLimiter(RedisLuaRateLimiter redisLimiter) {
        this.redisLimiter = redisLimiter;
        initSentinelRules();
    }
 
    /**
     * 执行全层级限流检查
     *
     * @param context 限流上下文
     * @return 限流结果
     */
    public RateLimitResult check(RateLimitContext context) {
        long start = System.nanoTime();
 
        try {
            // 层级 1: 用户级限流(最严格)
            if (!checkUserLevel(context)) {
                return RateLimitResult.rejected("USER_RATE_LIMIT",
                    "User-level rate limit exceeded", getRetryAfter(context.getUserId()));
            }
 
            // 层级 2: 设备级限流
            if (context.getDeviceId() != null && !checkDeviceLevel(context)) {
                return RateLimitResult.rejected("DEVICE_RATE_LIMIT",
                    "Device-level rate limit exceeded", getRetryAfter(context.getDeviceId()));
            }
 
            // 层级 3: IP 级限流
            if (context.getIp() != null && !checkIpLevel(context)) {
                return RateLimitResult.rejected("IP_RATE_LIMIT",
                    "IP-level rate limit exceeded", getRetryAfter(context.getIp()));
            }
 
            // 层级 4: 业务级限流
            if (!checkBusinessLevel(context)) {
                return RateLimitResult.rejected("BUSINESS_RATE_LIMIT",
                    "Business-level rate limit exceeded", 30);
            }
 
            // 层级 5: 全局级限流(Sentinel 兜底)
            if (!checkGlobalLevel(context)) {
                return RateLimitResult.rejected("GLOBAL_RATE_LIMIT",
                    "System overloaded, please retry later", 60);
            }
 
            return RateLimitResult.allowed();
 
        } finally {
            long latency = (System.nanoTime() - start) / 1_000_000;
            if (latency > 10) {
                log.warn("Rate limit check slow: {}ms, context={}", latency, context);
            }
        }
    }
 
    private boolean checkUserLevel(RateLimitContext ctx) {
        String userKey = "rl:user:" + ctx.getUserId() + ":" + ctx.getAction();
 
        return switch (ctx.getAction()) {
            case "WITHDRAW" ->
                // 提现:每用户每 24h 最多 5 次
                redisLimiter.slidingWindowAllow(userKey, 5, 86_400_000);
            case "LOGIN" ->
                // 登录:每用户每 1h 最多 10 次失败尝试(成功后重置)
                redisLimiter.slidingWindowAllow(userKey + ":fail", 10, 3_600_000);
            case "API_CALL" ->
                // API:每用户每秒 20 次(令牌桶允许突发)
                redisLimiter.tokenBucketAllow(userKey, 40, 20.0, 1);
            case "KYC_SUBMIT" ->
                // KYC 提交:每用户每 7 天 1 次
                redisLimiter.slidingWindowAllow(userKey, 1, 604_800_000);
            default -> true;
        };
    }
 
    private boolean checkDeviceLevel(RateLimitContext ctx) {
        String deviceKey = "rl:device:" + ctx.getDeviceId();
 
        // 设备级:每设备每小时最多注册 3 个账号
        if ("REGISTER".equals(ctx.getAction())) {
            return redisLimiter.slidingWindowAllow(deviceKey + ":reg", 3, 3_600_000);
        }
 
        // 设备级:每设备每 5 分钟最多 5 次提现尝试
        if ("WITHDRAW".equals(ctx.getAction())) {
            return redisLimiter.slidingWindowAllow(deviceKey + ":withdraw", 5, 300_000);
        }
 
        return true;
    }
 
    private boolean checkIpLevel(RateLimitContext ctx) {
        String ipKey = "rl:ip:" + ctx.getIp();
 
        // IP 基础限流:每分钟 60 次 API 调用
        boolean baseAllowed = redisLimiter.tokenBucketAllow(ipKey + ":api", 120, 60.0, 1);
        if (!baseAllowed) return false;
 
        // 高风险 IP(代理/VPN):每分钟 10 次
        if (ctx.isHighRiskIp()) {
            return redisLimiter.tokenBucketAllow(ipKey + ":api:risk", 20, 10.0, 1);
        }
 
        return true;
    }
 
    private boolean checkBusinessLevel(RateLimitContext ctx) {
        // 使用 Guava RateLimiter 作为单机业务保护
        String bizKey = ctx.getBusiness() + ":" + ctx.getAction();
        RateLimiter limiter = localLimiters.computeIfAbsent(bizKey, k -> {
            // 根据业务线动态配置速率
            double permitsPerSecond = getBusinessRate(ctx.getBusiness());
            return RateLimiter.create(permitsPerSecond);
        });
 
        // 尝试获取令牌,不阻塞(0 超时)
        return limiter.tryAcquire();
    }
 
    private boolean checkGlobalLevel(RateLimitContext ctx) {
        // Sentinel 全局兜底:保护系统整体不被打垮
        try {
            com.alibaba.csp.sentinel.Entry entry = com.alibaba.csp.sentinel.SphU.entry(
                "global:" + ctx.getBusiness());
            entry.exit();
            return true;
        } catch (BlockException ex) {
            log.warn("Global Sentinel block: business={}", ctx.getBusiness());
            return false;
        }
    }
 
    private double getBusinessRate(String business) {
        return switch (business) {
            case "SPOT" -> 5000.0;
            case "FUTURES" -> 3000.0;
            case "WITHDRAW" -> 500.0;
            case "LOGIN" -> 2000.0;
            default -> 1000.0;
        };
    }
 
    private int getRetryAfter(String dimension) {
        // 实际实现:查询 Redis 中该维度的下次可用时间
        return 60;
    }
 
    private void initSentinelRules() {
        List<FlowRule> rules = new ArrayList<>();
 
        // 全局提现限流:QPS 10000
        FlowRule withdrawRule = new FlowRule();
        withdrawRule.setResource("global:WITHDRAW");
        withdrawRule.setGrade(com.alibaba.csp.sentinel.slots.block.RuleConstant.FLOW_GRADE_QPS);
        withdrawRule.setCount(10000);
        withdrawRule.setLimitApp("default");
        rules.add(withdrawRule);
 
        // 全局登录限流:QPS 50000
        FlowRule loginRule = new FlowRule();
        loginRule.setResource("global:LOGIN");
        loginRule.setGrade(com.alibaba.csp.sentinel.slots.block.RuleConstant.FLOW_GRADE_QPS);
        loginRule.setCount(50000);
        loginRule.setLimitApp("default");
        rules.add(loginRule);
 
        FlowRuleManager.loadRules(rules);
        this.sentinelRules = rules;
    }
 
    // ========== 数据模型 ==========
 
    public record RateLimitContext(
        String userId,
        String deviceId,
        String ip,
        String action,      // WITHDRAW / LOGIN / API_CALL / REGISTER / KYC_SUBMIT
        String business,    // SPOT / FUTURES / MARGIN / EARN
        boolean isHighRiskIp
    ) {}
 
    public record RateLimitResult(
        boolean allowed,
        String code,
        String message,
        int retryAfterSeconds
    ) {
        static RateLimitResult allowed() {
            return new RateLimitResult(true, "ALLOWED", "OK", 0);
        }
        static RateLimitResult rejected(String code, String message, int retryAfter) {
            return new RateLimitResult(false, code, message, retryAfter);
        }
    }
}

3.5 集成 Sentinel 的热点参数限流

package com.大型加密货币交易所.risk.ratelimit;
 
import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowItem;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
 
import java.util.Arrays;
import java.util.Collections;
 
/**
 * Sentinel 热点参数限流:针对特定参数值(如特定用户、特定地址)的精准限流
 *
 * 场景:某个用户账号被盗,攻击者疯狂发起提现请求。
 *      热点参数限流可以在不影响到其他用户的情况下,
 *      单独对该用户进行限流或拉黑。
 */
public class SentinelHotParamRateLimiter {
 
    public SentinelHotParamRateLimiter() {
        initHotParamRules();
    }
 
    private void initHotParamRules() {
        // 规则:对 withdraw 接口的第 0 个参数(userId)进行热点限流
        ParamFlowRule rule = new ParamFlowRule("withdraw_api")
            .setParamIdx(0)  // 第 0 个参数是 userId
            .setCount(5)     // 默认每个 userId 每秒 5 次
            .setDurationInSec(1);
 
        // 热点例外:特定 userId 可以有不同的阈值
        ParamFlowItem hotItem1 = new ParamFlowItem()
            .setObject("12345")      // userId = 12345
            .setCount(1);            // 每秒最多 1 次(被标记为可疑的用户)
 
        ParamFlowItem hotItem2 = new ParamFlowItem()
            .setObject("VIP_999")    // VIP 用户
            .setCount(50);           // 每秒 50 次
 
        rule.setParamFlowItemList(Arrays.asList(hotItem1, hotItem2));
 
        ParamFlowRuleManager.loadRules(Collections.singletonList(rule));
    }
 
    public boolean tryWithdraw(String userId, String address, long amount) {
        Entry entry = null;
        try {
            // entryWithArgs 可以携带参数用于热点参数限流
            entry = SphU.entry("withdraw_api", userId);
 
            // 执行业务逻辑
            processWithdraw(userId, address, amount);
            return true;
 
        } catch (BlockException ex) {
            // 被热点参数限流拦截
            logHotParamBlock(userId, ex);
            return false;
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
    }
 
    private void processWithdraw(String userId, String address, long amount) {
        // 提现业务逻辑
    }
 
    private void logHotParamBlock(String userId, BlockException ex) {
        System.out.println("Hot param blocked: userId=" + userId + ", rule=" + ex.getRule());
    }
}

4. 业界案例

4.1 阿里巴巴:双 11 全链路限流与热点降级

背景:双 11 期间,淘宝/天猫面临每秒数百万笔交易的峰值,且存在"热点商品"问题——某款 iPhone 可能被数百万用户同时点击,形成热点 Key,压垮单台 Redis 或数据库分片。

解决方案:

  1. Sentinel 多层级限流:

    • 接口级:每个 API 有全局 QPS 上限(如商品详情页 100 万 QPS)
    • 应用级:每个微服务实例有线程池上限,防止雪崩
    • 热点参数级:对商品 ID 维度限流,单个商品 ID 的请求被分散到多个本地缓存节点
  2. 热点探测与本地缓存:

    • Sentinel 自动探测热点参数(如前 10 个被访问最多的商品 ID)
    • 热点数据从 Redis 降级到应用本地缓存(Caffeine),减少 90% 的 Redis 访问量
    • 热点数据变更时,通过 MetaQ 消息广播失效本地缓存
  3. 黑名单的 ZSET 实现:

    • 恶意买家名单存储在 Tair(阿里自研 KV)的 ZSET 中
    • 使用 ZREVRANGEBYSCORE 快速查询某用户是否在黑名单中
    • 黑名单有 TTL,自动过期释放误杀用户

踩过的坑:

  • 本地缓存不一致:某用户被加入黑名单后,由于本地缓存未同步,该用户仍在 5 分钟内可以下单。解决方案:黑名单变更强制走广播失效(而非等待 TTL),并增加数据库兜底校验(最终一致性)。
  • 限流粒度太粗:早期按 IP 限流导致 NAT 出口用户被误杀。解决方案:引入用户 ID + IP + 设备指纹的多维联合限流。

4.2 字节跳动:反爬与内容安全的灰名单体系

背景:字节系的抖音、TikTok 面临全球最大的爬虫和内容滥用攻击。爬虫特征:行为模式高度拟人,传统黑名单(IP/账号)容易被绕过。

解决方案:

  1. 动态灰名单(Dynamic Graylist):

    • 新注册用户默认进入观察池,前 7 天的所有行为被记录到 ClickHouse
    • 机器学习模型(XGBoost + 图神经网络)每日计算用户异常得分
    • 得分 0.6~0.8 进入灰名单:限制功能(不能评论、不能私信、内容限流)
    • 得分 > 0.8 进入黑名单:封号并上报设备指纹
  2. 设备指纹 + 关联图谱:

    • 收集 200+ 设备维度特征(Canvas 指纹、WebGL、字体列表、时区、电池 API)
    • 构建设备-账号-IP异构图,识别"一人多号"和"一号多设备"
    • 图中度中心性高的节点自动进入灰名单观察
  3. 自适应频控:

    • 普通用户:点赞每分钟 60 次
    • 灰名单用户:点赞每分钟 10 次,且每次点赞前需要滑动验证码
    • 黑名单关联设备:所有操作直接拒绝
  4. 阶梯限流的 gRPC 拦截器:

    // 自定义限流元数据
    message RateLimitMeta {
      string user_tier = 1;      // NORMAL / GRAY / BLACK
      string device_trust = 2;   // HIGH / MEDIUM / LOW
      string action_type = 3;    // LIKE / COMMENT / FOLLOW
      int32 base_quota = 4;      // 基础配额
      float multiplier = 5;      // 系数:NORMAL=1.0, GRAY=0.2, BLACK=0.0
    }

踩过的坑:

  • 灰名单震荡:用户反复在 NORMAL 和 GRAY 之间切换,体验极差。解决方案:引入磁滞(Hysteresis)机制——升级阈值 0.6,降级阈值 0.3,中间 0.3~0.6 区间保持原状态。
  • 隐私合规:欧盟 GDPR 要求设备指纹收集需明确 consent。解决方案:欧盟用户走弱指纹策略(仅收集 20 个特征),其他区域走强指纹。

4.3 补充:LinkedIn 的 anti-abuse rate limiting

LinkedIn 面对爬虫和自动化工具,采用ChronoGuard系统:

  • 时间序列特征:不仅限流"请求次数",还限流"请求间隔的熵值"——人类点击间隔服从对数正态分布,而机器人往往均匀分布。
  • Graph-based blacklisting:如果一个账号与多个已知黑名单账号有强关联(共享 IP、设备、支付卡),则该账号自动进入灰名单,限制其联系请求发送量。

5. 业务场景对照与注意事项

5.1 大型加密货币交易所 风控场景映射

业务场景黑名单应用白名单应用灰名单应用频控策略
提现 (Withdraw)制裁地址(OFAC/UN)直接阻断;被盗账户冻结VIP 用户提高单笔限额;KYC 通过用户降低审核新设备首次提现:延迟 24h + 邮件确认;大额提现:人工审核队列用户级:24h 5 次;地址级:同地址 24h 接收 3 笔;全局:10k QPS
登录 (Login)已知攻击 IP/代理 IP 库;泄露凭证账户内部员工 IP 段;已知可信设备异地登录/新设备:强制 2FA + 邮件通知用户级:1h 10 次失败;IP 级:1min 60 次;全局:50k QPS
交易下单 (Trade)市场操纵账户(wash trading)做市商账户:手续费减免 + 频控放宽新注册账户:前 30 天限制杠杆倍数用户级:每秒 10 单;IP 级:每秒 100 单;全局:100 万 QPS
KYC 提交伪造证件特征库;已知欺诈身份企业认证用户高风险国籍/地区用户:增强尽调每用户 7 天 1 次;人工审核队列长度限流
API Key 调用异常调用模式(固定间隔刷数据)Partner API:独立限流配额新 API Key:前 7 天限制调用频率,观察模式按 API Key 限流;按 IP 限流;全局 API Gateway 限流
充币 (Deposit)暗网/混币器地址黑名单(Chainalysis 数据)已知合规交易所地址大额充币:延迟确认 + 来源分析地址级:无严格频控,但大额触发 AML 审查

5.2 常见误区 vs 正确做法

❌ 常见误区✅ 正确做法
黑名单直接返回"拒绝",暴露风控逻辑静默拒绝(Shadow Ban)或返回通用错误码,延迟响应时间防止时序攻击
名单存储在数据库,每次查询走 DBL1 本地缓存 + L2 Redis,DB 仅用于持久化和冷启动加载
限流只限制 QPS,不考虑业务语义区分"读限流"和"写限流",写操作限流更严格;区分"正常流量"和"失败流量"(登录失败单独计数)
黑名单永久有效,不设置 TTL名单必须有过期机制和申诉通道,防止误杀长期无法恢复
灰名单只是"弱版黑名单"灰名单是独立策略集合:降低限额、增加摩擦(friction)、延迟执行,而非简单放行或拒绝
限流 key 只用 userId多维 key:userId + deviceId + IP + sessionId,防止盗用身份绕过
全局限流一刀切按业务线、用户等级、地域分级,VIP 用户和系统监控流量不受全局限流影响
名单更新同步阻塞主线程名单更新走异步消息(Kafka/RabbitMQ),本地缓存最终一致性

5.3 选型建议

场景推荐方案不推荐
高频名单查询(>10k QPS)Caffeine/Guava 本地缓存 + Redis Pub/Sub 同步直接查数据库
精准限流(验证码/提现)Redis + Lua 滑动窗口令牌桶(边界突发问题)
API 网关限流(允许突发)Guava RateLimiter / Sentinel 令牌桶漏桶(过于严格)
流量整形(固定输出速率)漏桶 / Nginx limit_req zone令牌桶
动态热点防护Sentinel 热点参数限流固定规则
全局系统保护Sentinel QPS 限流 + 自适应降载单点 Redis(会成为瓶颈)

6. FAQ 与高频追问

Q1:滑动窗口和令牌桶的核心区别是什么?在什么场景下必须选滑动窗口?

答:

核心区别:

  • 滑动窗口保证的是"在最近 N 时间单位内,请求数不超过 M",是绝对精确的。不允许任何突发超出限额。
  • 令牌桶保证的是"长期平均速率不超过 r,但允许最多 C 的突发",是相对宽松的。允许瞬时突发。

必须选滑动窗口的场景:

  1. 严格计数场景:发送短信验证码("每手机号每 60 秒最多 1 条"),绝不能允许 1.01 秒内发 2 条。
  2. 资损场景:提现次数限制("每用户每天最多 5 笔"),不能用令牌桶导致窗口边界多提一笔。
  3. 合规场景:API 调用配额(OAuth rate limit),超出即违规,不允许 burst。

选令牌桶的场景:

  1. API 网关限流:用户正常操作有突发(如页面刷新同时触发 5 个 API),允许短突发但限制长期平均。
  2. 带宽控制:网络流量整形,允许文件下载开始时快速填充缓冲区。

追问深挖:面试官可能问"Redis 滑动窗口的内存开销怎么优化?"

  • 答:不用 ZSET 存储每个请求的时间戳,改用 ** Sliding Window Log 的近似算法**(如分桶计数,将 1 分钟分为 6 个 10 秒桶,只记录 6 个整数),牺牲少量精度换取 O(1) 内存。Sentinel 的滑动窗口就是这么实现的。

Q2:分布式环境下,多个服务节点如何保证限流的严格一致性?Redis 挂了怎么办?

答:

三层降级策略:

  1. 正常态(Redis 健康):

    • 所有限流判断走 Redis + Lua 原子操作,严格一致性
    • 使用 Redis Cluster,分片存储不同维度的限流 key
  2. 降级态(Redis 慢/部分不可用):

    • 切换到本地计数器(每个 JVM 实例维护一个内存计数器)
    • 由于失去了全局一致性,本地限流阈值需要按实例数均分:全局 10000 QPS,10 个实例则每个实例限 1000 QPS
    • 引入gossip 协议或广播机制,让实例间共享部分状态(如黑名单更新)
  3. 兜底态(Redis 完全不可用):

    • 启动静态名单:服务启动时从本地配置文件加载最核心的黑名单(制裁地址、已知攻击 IP)
    • 开启全局限流开关:Nginx/Envoy 层硬限制(如单 IP 最大连接数),保护后端
    • 进入只读模式或排队模式:写操作(提现、下单)进入消息队列延迟处理,读操作继续服务

关键设计:

  • 限流组件必须有 health check 和熔断机制,自动感知 Redis 状态
  • 本地缓存的预热机制:启动时从 Redis 加载热点数据,避免冷启动穿透
  • 影子模式:降级期间,本地限流的同时异步尝试恢复 Redis 连接,一旦恢复平滑切换

Q3:黑名单更新后,本地缓存的脏读怎么解决?要求"更新后 100ms 内全局生效"如何实现?

答:

100ms 内全局生效的架构:

名单管理中心 (Admin Service)
    |
    | 1. 写入 MySQL(持久化)
    | 2. 写入 Redis( SET key value EX 3600 )
    | 3. 发布 Redis Pub/Sub 消息:{action: "INVALIDATE", key: "user:123", type: "BLACKLIST"}
    v
Redis Cluster ----Pub/Sub----> 所有应用节点
                                    |
                                    v
                            本地缓存 Caffeine/Guava
                                    |
                                    v
                            收到消息后立即 invalidate(key)

关键实现细节:

  1. Pub/Sub 可靠性:Redis Pub/Sub 不保证消息必达(客户端断连期间的消息丢失)。解决方案:

    • 使用 Redis Stream 或 Kafka 作为可靠消息通道
    • 每个消费者维护消费位点,断连后从上次位点续读
    • 兜底:本地缓存设置短 TTL(如 30 秒),最坏情况 30 秒后自动失效
  2. 批量失效:如果一次性更新 10 万个黑名单,不能发 10 万条消息。解决方案:

    • 消息格式支持 pattern invalidate:{action: "INVALIDATE_PATTERN", pattern: "risk:list:black:*"}
    • 本地缓存遍历所有 key,匹配 pattern 的立即失效
  3. 写穿透保护:更新期间,查询请求可能打到已失效的本地缓存。解决方案:

    • 延迟双删:先删缓存 -> 写 Redis -> 等 100ms -> 再发 invalidate 消息 -> 再等 500ms -> 第三次确认删除
    • 或者使用 Cache Aside + 版本号:每次名单条目带版本号,本地缓存只缓存最新版本
  4. 100ms 量化分解:

    • 写 Redis:1ms
    • 发 Kafka 消息:5ms
    • Kafka 消费 + 本地失效:10ms
    • 网络传播 + 处理:20ms
    • 兜底 TTL:30s
    • 实际 P99 通常在 50ms 内

Q4:灰名单中的"观察期"设计有哪些陷阱?如何防止用户永远卡在灰名单中无法恢复?

答:

五大陷阱与对策:

陷阱现象对策
震荡(Oscillation)用户评分在阈值上下波动,反复进出灰名单引入磁滞带:升级阈值 0.6,降级阈值 0.3,0.3~0.6 之间保持状态不变
冷冻(Freezing)用户进入灰名单后,系统不再评估其新行为,永远卡住强制定期重评:灰名单用户每天至少重新计算一次评分,无论是否有新行为
证据衰减(Evidence Decay)用户 3 个月前的一次异常至今仍影响评分引入时间衰减函数:w(t) = exp(-λt),老证据权重指数下降
观察期无限延长每次新异常都重置观察期 TTL,导致永不过期观察期上限:无论多少次异常,最大观察期不超过 30 天
灰名单泛滥阈值设置过低,大量正常用户进入灰名单基线校准:定期分析灰名单转化率(灰->黑 / 灰->白),转化率 < 10% 说明阈值过松

恢复机制设计:

// 灰名单自动恢复的条件(满足任一即可)
public boolean canRecoverFromGray(String userId) {
    GrayRecord record = graylistDao.find(userId);
 
    // 条件 1: 观察期自然结束且期间无新异常
    if (record.getObservationEnd().isBefore(Instant.now())
        && record.getNewAnomaliesDuringGray() == 0) {
        return true;
    }
 
    // 条件 2: 连续 N 天行为评分低于恢复阈值
    List<Double> recentScores = record.getLastNDaysScores(7);
    if (recentScores.size() >= 7
        && recentScores.stream().allMatch(s -> s < THETA_RECOVER)) {
        return true;
    }
 
    // 条件 3: 用户主动完成增强验证(人脸 + 视频 + 手持证件)
    if (record.hasCompletedEnhancedVerification()
        && record.getEnhancedVerificationResult() == PASSED) {
        return true;
    }
 
    // 条件 4: 人工审核通过(客服/风控运营介入)
    if (record.getManualReviewResult() == APPROVED) {
        return true;
    }
 
    return false;
}

追问深挖:"如果灰名单用户申诉,怎么防止攻击者批量申诉绕过?"

  • 答:申诉本身也要限流——每个用户每月最多申诉 1 次,申诉需人脸识别 + 活体检测,申诉材料进入人工审核队列(审核员每日处理上限)。

Q5:在交易所场景中,黑名单误杀一个合规用户(如某国政要亲属)会造成什么后果?如何设计误杀防护?

答:

误杀的代价:

  1. 监管风险:OFAC 误封可能是"宁可错杀",但误封本国合规用户可能触发监管调查和罚款(如 FCA/MAS 对不公平对待客户的处罚)。
  2. 声誉风险:KOL 用户在 Twitter 上发声,引发舆论危机。
  3. 法律风险:某些司法管辖区(欧盟)要求解释自动化决策权(GDPR Article 22),用户有权知道为什么被拉黑。
  4. 资金风险:用户资产被冻结期间的利息损失可能触发赔偿。

误杀防护的六层设计:

Layer 1: 自动黑名单前置拦截
    |
    v
Layer 2: 高风险操作人工审核队列(>10k USDT 提现必须人审)
    |
    v
Layer 3: 灰名单自动降级机制(误杀用户可在灰名单中恢复)
    |
    v
Layer 4: 申诉通道 + 证据保全(用户可提交材料自证清白)
    |
    v
Layer 5: 样本回溯审计(每日抽查 1% 黑名单决策,人工复核)
    |
    v
Layer 6: 误杀补偿与上报(确认误杀后,补偿 + 根因分析 + 规则修复)

具体措施:

  1. 白名单覆盖机制:

    • 已知的高价值客户(通过 KYC Level 3 的企业账户)默认进入保护白名单
    • 白名单用户触发黑名单规则时,不直接阻断,而是进入优先人工审核队列(15 分钟内有人处理)
  2. 双轨制执行:

    • 硬黑名单(制裁名单):机器自动执行,无人工干预
    • 软黑名单(模型/规则命中):触发增强验证,用户可以"自证清白"完成交易
  3. 样本审计(Sample Audit):

    • 每日随机抽取 1% 的黑名单命中案例,由二级风控人工复核
    • 如果人工认为误杀率 > 5%,自动回退该规则并告警
  4. A/B Test 与影子模式:

    • 新黑名单规则上线时,先走影子模式(只记录决策但不执行),观察 7 天
    • 误杀率 < 0.1% 且命中率 > 80% 才切换为执行模式
  5. 解释性输出(Explainability):

    • 每个黑名单决策记录触发规则 ID、特征值、阈值、模型得分
    • 用户申诉时,风控人员可快速定位原因(如"触发规则 R-472:IP 归属地与注册地不一致,且 24h 内 3 次改绑手机")
  6. 熔断与回滚:

    • 规则支持秒级下线:通过配置中心推送,所有节点 5 秒内停止执行该规则
    • 支持批量恢复:确认误杀后,一键将受影响用户从黑名单移出并补偿

Q6(附加):如何应对基于"慢速攻击"(Low-and-Slow Attack)的绕过?

答:

慢速攻击特征:攻击者不暴力冲撞,而是精确控制请求速率略低于限流阈值,长期执行。

例如:

  • 限流阈值:每 IP 每分钟 60 次登录
  • 攻击模式:每 1.1 秒 1 次登录,持续 24 小时 = 78500 次尝试

检测与防御:

  1. 行为模式分析:

    • 正常用户登录间隔服从对数正态分布(大部分在 1 秒~1 小时,极少固定间隔)
    • 攻击者往往使用固定间隔或均匀分布
    • 计算请求间隔的熵值和变异系数(CV),CV < 0.1 且熵值低则标记为机器行为
  2. 长期滑动窗口:

    • 不仅限流"每分钟",还限流"每小时"、"每天"
    • 每小时 100 次且每天 500 次,攻击者即使绕过分钟级限制,也会触发小时级/天级限制
  3. 关联限流:

    • 单 IP 未超限,但该 IP 下的 100 个用户各发起 10 次登录 → 总共 1000 次
    • 实现:维护 IP -> User Set 的映射,当某 IP 关联的独立用户数在 1 小时内超过 20 个,触发 IP 级限流
  4. 挑战-响应(Challenge):

    • 对慢速攻击不直接阻断,而是增加摩擦:要求验证码、滑动验证、设备指纹校验
    • 攻击者成本上升后自然放弃

一句话总结:黑白灰名单是风控的"交通信号灯"(红停绿行黄观察),频控限流是"道路限速牌"(不同车道不同限速)。真正的高可用体系不是单一机制的堆叠,而是本地缓存的极速判定 + Redis 的分布式一致性 + 灰名单的智能过渡 + 阶梯限流的多维防护的有机协同,核心目标是在毫秒级内做出"不漏杀、不误杀、不压垮"的最优决策。