限流、熔断与降级：Sentinel 与 Hystrix 原理

// 令牌桶（Token Bucket）—— Sentinel 流控的核心
速率：每秒产生 10 个令牌（QPS = 10）
桶容量：最多存 20 个令牌（允许突发 20 个请求）
// 请求来了 → 取令牌 → 有令牌则通过 → 没令牌则拒绝

// 滑动窗口（Sliding Window）—— Sentinel 统计的核心
窗口：1 秒，拆分为 2 个格子（每个 500ms）
// 每个格子记录通过/拒绝的请求数
// 统计时只看当前时间往前 1 秒内的格子
// 格子越多精度越高，但内存开销也越大

public class CircuitBreaker {
    enum State { CLOSED, OPEN, HALF_OPEN }

    private State state = State.CLOSED;
    private int failureCount = 0;
    private int successCount = 0;
    private long lastFailureTime;
    private final int FAILURE_THRESHOLD = 5;     // 失败次数阈值
    private final long OPEN_TIMEOUT = 10000;     // 熔断持续时间（ms）
    private final int HALF_OPEN_REQUESTS = 3;    // 半开状态探测请求数

    public <T> T execute(Supplier<T> supplier) {
        switch (state) {
            case OPEN:
                if (System.currentTimeMillis() - lastFailureTime > OPEN_TIMEOUT) {
                    state = State.HALF_OPEN; // 超时了，转为半开
                } else {
                    throw new CircuitBreakerOpenException(); // 快速失败
                }
            case HALF_OPEN:
                try {
                    T result = supplier.get();
                    successCount++;
                    if (successCount >= HALF_OPEN_REQUESTS) {
                        reset(); // 探测成功，恢复关闭
                    }
                    return result;
                } catch (Exception e) {
                    state = State.OPEN; // 探测失败，回到打开
                    lastFailureTime = System.currentTimeMillis();
                    throw e;
                }
            case CLOSED:
            default:
                try {
                    return supplier.get();
                } catch (Exception e) {
                    failureCount++;
                    if (failureCount >= FAILURE_THRESHOLD) {
                        state = State.OPEN; // 失败超阈值，熔断
                        lastFailureTime = System.currentTimeMillis();
                    }
                    throw e;
                }
        }
    }
}

// Hystrix 的隔离策略：每个服务调用一个独立线程池

优点：
  服务 A 的线程池满了 → 只影响对 A 的调用
  → 不会拖垮服务 B 的调用
  → 实现了舱壁隔离（Bulkhead）

缺点：
  每个调用都需要线程切换（context switch）
  → 在高并发下开销很大
  → 线程池参数（核心线程数、最大线程数、队列大小）需要调优

// Sentinel 的选择：信号量隔离
优点：
  不需要线程切换，在当前线程执行
  → 性能更好
  → 通过计数器（AtomicInteger）控制并发数

缺点：
  无法像线程池那样强制中断超时请求
  → 需要依赖框架级别的超时机制

1. 自动降级（熔断触发）
   下游服务熔断 → 自动执行 Fallback 逻辑
   // 例：推荐服务挂了 → 返回默认推荐列表

2. 手动降级（开关控制）
   运维通过配置中心关闭非核心功能
   // 例：大促时关闭"猜你喜欢"、"个性化广告"

3. 超时降级
   调用超时 → 返回缓存数据或默认值
   // 例：价格服务超时 → 返回上次缓存的价格

4. 限流降级
   超出限流阈值的请求 → 返回友好提示
   // 例："当前排队人数较多，请稍后再试"

// Sentinel 的降级回调（BlockHandler + Fallback）

@SentinelResource(
    value = "getProductDetail",
    blockHandler = "getProductDetailBlock",   // 限流/熔断时的处理
    fallback = "getProductDetailFallback"     // 业务异常时的处理
)
public ProductDetail getProductDetail(Long productId) {
    return productService.getById(productId);
}

// 限流/熔断时：返回友好提示
public ProductDetail getProductDetailBlock(Long productId, BlockException ex) {
    return ProductDetail.defaultInstance(); // 默认商品详情
}

// 业务异常时：返回缓存数据
public ProductDetail getProductDetailFallback(Long productId, Throwable t) {
    return cacheService.getProductDetail(productId); // Redis 缓存
}

// 场景一：防止某个热门商品被疯狂刷单
// 接口：GET /product/{productId}
// 规则：productId = "爆款A" 时，QPS 不超过 100
//       其他 productId 正常限流 QPS = 1000

// 场景二：防止某个用户频繁调用接口
// 接口：POST /api/query
// 规则：userId = "恶意用户X" 时，QPS 不超过 5

// 场景三：大促秒杀
// 接口：POST /seckill/{skuId}
// 规则：每个用户（userId）每秒最多 1 次秒杀请求

@SentinelResource(value = "getProduct")
public Product getProduct(
    @SentinelParam String productId,  // 第一个参数
    @SentinelParam String userId      // 第二个参数
) {
    return productService.getById(productId);
}

// 控制台配置热点规则：
// 资源名：getProduct
// 参数索引：0（productId）
// 单机阈值：1000
// 例外项：productId = "爆款A" → 阈值 100

1. 快速失败（默认）
   超过阈值的请求 → 直接抛 FlowException
   // 适合：接口幂等、可以重试的场景

2. Warm Up（预热模式）
   冷启动：系统刚启动时阈值较低，逐渐升高到设定值
   // 原理：JIT 编译需要时间，刚启动时性能低于稳态
   // 预热时长：默认 10 秒，期间阈值从 1/3 逐渐升高到全量
   // 适合：秒杀开始时避免瞬间流量压垮系统

3. 排队等待（匀速排队）
   超过阈值的请求 → 进入等待队列 → 按固定间隔放行
   // 原理：漏桶算法，保证请求均匀通过
   // 超时时间：排队超过 maxQueueingTimeMs → 拒绝
   // 适合：脉冲流量场景，把突发请求"拉平"

// Sentinel 流控规则配置示例
FlowRule rule = new FlowRule();
rule.setResource("getProduct");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // 按 QPS 限流
rule.setCount(1000);                         // 阈值 1000 QPS
rule.setControlBehavior(                      // 流控行为
    RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER); // 匀速排队
rule.setMaxQueueingTimeMs(2000);             // 最多排队 2 秒

// 系统保护的五种触发条件（任一满足即触发限流）

1. Load 保护
   系统 Load > 阈值（如 5.0）时触发
   → 适用于 Linux 系统

2. CPU 使用率保护
   CPU 使用率 > 阈值（如 80%）时触发
   → 最常用，响应最灵敏

3. 总线程数保护
   并发线程数 > 阈值（如 500）时触发
   → 防止线程数过多导致上下文切换开销过大

4. 入口 QPS 保护
   总入口 QPS > 阈值时触发
   → 全局流量控制

5. 平均 RT 保护
   平均响应时间 > 阈值（如 200ms）时触发
   → 响应变慢说明系统已经过载