← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
一、理论篇:高并发核心方法论(30%)二、实战篇:Sentinel Spring Boot集成(40%)三、面试模拟篇(20%)四、练习篇(10%)关键知识点速查表

P4-01 高并发系统设计方法论

适用对象:5年经验Java开发者,目标薪资18-22K
课时:约3小时 | 理论30% + 实战40% + 面试20% + 练习10%

一、理论篇:高并发核心方法论(30%)

1.1 高并发系统的本质挑战

高并发系统的核心矛盾是:有限的资源 vs 无限的请求。

解决思路围绕三把斧展开:


用户请求 → [限流] → [熔断判断] → [业务逻辑] → [降级兜底]
              ↓           ↓                          ↓
           拒绝请求    快速失败                   返回默认值

1.2 四大限流算法详解

固定窗口计数器(Fixed Window)


|-------- 100 --------|-------- 100 --------|
                      ↑ 边界突发
              99 ↑100个|100个↑
              0.1s内通过200个请求

滑动窗口计数器(Sliding Window)


格子: |0.0|0.1|0.2|0.3|0.4|0.5|0.6|0.7|0.8|0.9|
计数: | 8 |12 | 9 |11 |10 | 8 |13 | 9 |10 | ? |
      ↑ 滑动统计最近1秒的总计数 ↑

令牌桶算法(Token Bucket)


          令牌以 rate 个/s 放入
               ↓ ↓ ↓ ↓
          ┌──────────────┐
          │ ○ ○ ○ ○ ○ ○  │ ← 令牌桶(容量 burst)
          │ ○ ○ ○ ○      │
          └──────┬───────┘
                 │ 每个请求取走一个令牌
                 ↓
             请求处理

漏桶算法(Leaky Bucket)


          请求涌入(不均匀)
          ↓ ↓↓↓ ↓↓ ↓ ↓↓↓↓
          ┌──────────────┐
          │  █ █ █ █ █ █  │ ← 漏桶(队列)
          └──────┬───────┘
                 │ 恒定速率流出
                 ↓ ↓ ↓ ↓ ↓
             匀速处理

四种算法对比

维度固定窗口滑动窗口令牌桶漏桶
突发流量2倍泄漏较平滑允许突发绝对平滑
实现复杂度低中中中
内存消耗低较高低低
适用场景粗粒度限流精确限流API限流流量整形

1.3 熔断器模式(Circuit Breaker)

熔断器三种状态:


          成功率恢复
     ┌──────────────────────┐
     ↓                      │
  [CLOSED] ──失败率超阈值──→ [OPEN] ──超时后──→ [HALF_OPEN]
  正常放行                   直接拒绝          放行少量请求探测
                                                  │
                                          成功率达标 → CLOSED
                                          失败率高  → OPEN

关键参数:

1.4 优雅降级策略

降级优先级从低到高:

1. 返回兜底数据:如推荐系统返回热门商品

2. 异步处理:同步转异步,返回"处理中"

3. 关闭非核心功能:如关闭评论、关闭推荐

4. 页面静态化:返回CDN缓存的静态页面

5. 拒绝服务:只拒绝低优先级用户

1.5 幂等设计

幂等性:同一操作执行一次与执行多次的效果相同。

Token机制


客户端 ──请求Token──→ 服务端(Redis存储Token)
客户端 ──携带Token提交──→ 服务端(验证并删除Token)
                          ↓
                    Token存在 → 执行业务 → 删除Token
                    Token不存在 → 重复请求,拒绝

数据库唯一约束


-- 利用唯一索引保证幂等
ALTER TABLE orders ADD UNIQUE INDEX uk_order_id (order_id);
-- 插入重复订单会抛出DuplicateKeyException

状态机幂等


// 只允许状态单向流转
UPDATE orders SET status = 'PAID' 
WHERE order_id = ? AND status = 'UNPAID';
-- 影响行数为0说明已处理过

二、实战篇:Sentinel Spring Boot集成(40%)

2.1 项目依赖


<dependencies>
    <!-- Sentinel核心 -->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-core</artifactId>
        <version>1.8.7</version>
    </dependency>
    <!-- Sentinel注解支持 -->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-annotation-aspectj</artifactId>
        <version>1.8.7</version>
    </dependency>
    <!-- Sentinel Spring Cloud适配 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        <version>2022.0.0.0</version>
    </dependency>
</dependencies>

2.2 限流规则配置


@Configuration
public class SentinelConfig {

    @PostConstruct
    public void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();

        // API接口限流:QPS限制为100
        FlowRule apiRule = new FlowRule();
        apiRule.setResource("orderService.createOrder");
        apiRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        apiRule.setCount(100);
        apiRule.setLimitApp("default");
        // 采用滑动窗口 + 令牌桶组合策略
        apiRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
        apiRule.setWarmUpPeriodSec(10); // 预热10秒
        rules.add(apiRule);

        // 热点参数限流:按用户ID限流
        ParamFlowRule hotRule = new ParamFlowRule();
        hotRule.setResource("orderService.queryOrder");
        hotRule.setParamIdx(0); // 第一个参数
        hotRule.setCount(50);
        hotRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 特定用户限流
        ParamFlowItem item = new ParamFlowItem()
            .setObject("vip-user-001")
            .setClassType(String.class.getName())
            .setCount(200); // VIP用户放宽到200
        hotRule.setParamFlowItemList(Collections.singletonList(item));

        FlowRuleManager.loadRules(rules);
        ParamFlowRuleManager.loadRules(Collections.singletonList(hotRule));
    }
}

2.3 熔断降级规则


@Configuration
public class DegradeRuleConfig {

    @PostConstruct
    public void initDegradeRules() {
        List<DegradeRule> rules = new ArrayList<>();

        // 慢调用比例熔断
        DegradeRule slowCallRule = new DegradeRule("orderService.createOrder");
        slowCallRule.setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
        slowCallRule.setCount(0.5); // 慢调用比例阈值50%
        slowCallRule.setSlowRatioThreshold(0.5);
        slowCallRule.setTimeWindow(30); // 熔断持续30秒
        slowCallRule.setMinRequestAmount(10); // 最小请求数
        slowCallRule.setStatIntervalMs(10000); // 统计时长10秒
        rules.add(slowCallRule);

        // 异常比例熔断
        DegradeRule errorRateRule = new DegradeRule("paymentService.pay");
        errorRateRule.setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType());
        errorRateRule.setCount(0.3); // 异常比例30%
        errorRateRule.setTimeWindow(60);
        errorRateRule.setMinRequestAmount(5);
        errorRateRule.setStatIntervalMs(60000);
        rules.add(errorRateRule);

        DegradeRuleManager.loadRules(rules);
    }
}

2.4 注解方式使用Sentinel


@Service
@Slf4j
public class OrderService {

    /**
     * 创建订单 - 限流 + 熔断 + 降级
     */
    @SentinelResource(
        value = "orderService.createOrder",
        blockHandler = "createOrderBlockHandler",
        blockHandlerClass = OrderBlockHandler.class,
        fallback = "createOrderFallback",
        fallbackClass = OrderFallbackHandler.class
    )
    public OrderResult createOrder(CreateOrderRequest request) {
        // 核心业务逻辑
        log.info("创建订单: userId={}, productId={}", 
                 request.getUserId(), request.getProductId());
        
        // 模拟业务处理
        Order order = new Order();
        order.setOrderId(IdWorker.getIdStr());
        order.setUserId(request.getUserId());
        order.setProductId(request.getProductId());
        order.setAmount(request.getAmount());
        order.setStatus(OrderStatus.CREATED);
        
        orderMapper.insert(order);
        return OrderResult.success(order);
    }
}

// =================== 限流处理(BlockHandler) ===================
public class OrderBlockHandler {
    /**
     * 限流/熔断时的处理 - 必须是static方法
     * 参数最后需要加BlockException
     */
    public static OrderResult createOrderBlockHandler(
            CreateOrderRequest request, BlockException ex) {
        log.warn("订单创建被限流/熔断: rule={}", ex.getRule());
        // 触发限流,返回友好提示
        return OrderResult.fail("系统繁忙,请稍后重试");
    }
}

// =================== 业务降级处理(Fallback) ===================
public class OrderFallbackHandler {
    /**
     * 业务异常时的降级处理 - 必须是static方法
     * 参数最后需要加Throwable
     */
    public static OrderResult createOrderFallback(
            CreateOrderRequest request, Throwable throwable) {
        log.error("订单创建异常,执行降级: {}", throwable.getMessage());
        // 返回兜底数据或异步处理标识
        return OrderResult.fail("服务暂时不可用,已记录您的请求");
    }
}

2.5 幂等Token完整实现


@RestController
@RequestMapping("/api/order")
@Slf4j
public class OrderController {

    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private OrderService orderService;

    private static final String TOKEN_PREFIX = "idempotent:token:";

    /**
     * 第一步:获取幂等Token
     */
    @GetMapping("/token")
    public Result<String> getToken(@RequestParam Long userId) {
        String token = UUID.randomUUID().toString().replace("-", "");
        String key = TOKEN_PREFIX + userId + ":" + token;
        // Token有效期15分钟
        redisTemplate.opsForValue().set(key, "1", 15, TimeUnit.MINUTES);
        return Result.success(token);
    }

    /**
     * 第二步:提交订单(携带Token)
     */
    @PostMapping("/create")
    public Result<OrderVO> createOrder(
            @RequestBody CreateOrderRequest request,
            @RequestHeader("X-Idempotent-Token") String token) {

        // 幂等校验:原子性删除Token
        String key = TOKEN_PREFIX + request.getUserId() + ":" + token;
        Boolean deleted = redisTemplate.delete(key);
        
        if (deleted == null || !deleted) {
            // Token不存在或已被消费 → 重复请求
            log.warn("重复请求被拒绝: userId={}, token={}", 
                     request.getUserId(), token);
            return Result.fail("请勿重复提交");
        }

        // Token验证通过,执行业务
        OrderResult result = orderService.createOrder(request);
        return Result.success(result);
    }
}

2.6 Sentinel Dashboard接入


# application.yml
spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080  # Sentinel控制台地址
        port: 8719                 # 与控制台通信端口
      eager: true                  # 项目启动即注册
      web-context-unify: false     # 关闭上下文聚合
      http-method-specify: true    # 区分HTTP方法

三、面试模拟篇(20%)

Q1:设计一个分布式限流器

面试官:请你设计一个分布式环境下的限流器,支持每秒1000次的速率限制。

参考回答:

首先确认需求:

方案选择:基于Redis + Lua脚本实现滑动窗口限流。

核心思路:

1. 用Redis的Sorted Set存储请求时间戳作为score

2. 每次请求执行Lua脚本:清除窗口外旧数据 → 统计窗口内数量 → 判断是否超限

3. Lua脚本保证原子性,避免并发问题


-- distributed_rate_limiter.lua
local key = KEYS[1]
local window = tonumber(ARGV[1])   -- 窗口大小(毫秒)
local limit = tonumber(ARGV[2])    -- 限流阈值
local now = tonumber(ARGV[3])      -- 当前时间戳(毫秒)

-- 移除窗口外的旧数据
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)

-- 统计当前窗口内请求数
local count = redis.call('ZCARD', key)

if count < limit then
    -- 未超限,添加当前请求
    redis.call('ZADD', key, now, now .. '-' .. math.random(1000000))
    -- 设置过期时间,避免内存泄漏
    redis.call('EXPIRE', key, math.ceil(window / 1000))
    return 1  -- 允许
else
    return 0  -- 拒绝
end

性能优化:

Q2:如何应对突发流量(如热搜、秒杀)

面试官:线上突然来了一波平时10倍的流量,系统快要扛不住了,你怎么处理?

参考回答(按紧急程度排序):

第一层:紧急止血(1分钟内)

第二层:容量扩展(5分钟内)

第三层:流量调度(10分钟内)

第四层:事后复盘

Q3:令牌桶和漏桶的区别?分别用在哪里?

关键对比点:


四、练习篇(10%)

练习1:实现多级限流

要求:实现"IP维度的全局限流 + 用户维度的接口限流"二级限流体系。


// 提示:使用Sentinel的链式规则
// 1. IP维度全局限流 1000 QPS
// 2. 用户维度每接口 50 QPS
// 请补充代码

练习2:幂等组件封装

要求:封装一个@Idempotent注解,基于AOP + Redis实现声明式幂等控制。


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Idempotent {
    /** 幂等key的SpEL表达式 */
    String key();
    /** 有效期(秒),默认60秒 */
    int expire() default 60;
    /** 提示信息 */
    String message() default "请勿重复操作";
}

// 请实现IdempotentAspect切面

练习3:熔断器状态机模拟

要求:不依赖任何框架,用Java实现一个简易的CircuitBreaker,包含CLOSED/OPEN/HALF_OPEN三种状态转换。


关键知识点速查表

概念核心要点一句话总结
固定窗口简单但有边界突发粗糙但够用
滑动窗口细粒度格子统计精确限流首选
令牌桶允许突发,控制平均速率API限流标配
漏桶强制匀速输出流量整形利器
熔断器三态切换保护系统系统的保险丝
降级牺牲非核心保核心断臂求生
幂等同一操作多次结果一致防重复提交的根本

下一篇:P4-02-秒杀系统完整实现 → 从0到1搭建完整的秒杀系统