适用对象:5年经验Java开发者,目标薪资18-22K
课时:约3小时 | 理论30% + 实战40% + 面试20% + 练习10%
高并发系统的核心矛盾是:有限的资源 vs 无限的请求。
解决思路围绕三把斧展开:
用户请求 → [限流] → [熔断判断] → [业务逻辑] → [降级兜底]
↓ ↓ ↓
拒绝请求 快速失败 返回默认值
|-------- 100 --------|-------- 100 --------|
↑ 边界突发
99 ↑100个|100个↑
0.1s内通过200个请求
格子: |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秒的总计数 ↑
令牌以 rate 个/s 放入
↓ ↓ ↓ ↓
┌──────────────┐
│ ○ ○ ○ ○ ○ ○ │ ← 令牌桶(容量 burst)
│ ○ ○ ○ ○ │
└──────┬───────┘
│ 每个请求取走一个令牌
↓
请求处理
请求涌入(不均匀)
↓ ↓↓↓ ↓↓ ↓ ↓↓↓↓
┌──────────────┐
│ █ █ █ █ █ █ │ ← 漏桶(队列)
└──────┬───────┘
│ 恒定速率流出
↓ ↓ ↓ ↓ ↓
匀速处理
| 维度 | 固定窗口 | 滑动窗口 | 令牌桶 | 漏桶 |
|---|---|---|---|---|
| 突发流量 | 2倍泄漏 | 较平滑 | 允许突发 | 绝对平滑 |
| 实现复杂度 | 低 | 中 | 中 | 中 |
| 内存消耗 | 低 | 较高 | 低 | 低 |
| 适用场景 | 粗粒度限流 | 精确限流 | API限流 | 流量整形 |
熔断器三种状态:
成功率恢复
┌──────────────────────┐
↓ │
[CLOSED] ──失败率超阈值──→ [OPEN] ──超时后──→ [HALF_OPEN]
正常放行 直接拒绝 放行少量请求探测
│
成功率达标 → CLOSED
失败率高 → OPEN
关键参数:
slowCallRateThreshold:慢调用比例阈值failureRateThreshold:失败率阈值(默认50%)waitDurationInOpenState:熔断持续时间(默认60s)permittedNumberOfCallsInHalfOpenState:半开状态放行请求数降级优先级从低到高:
1. 返回兜底数据:如推荐系统返回热门商品
2. 异步处理:同步转异步,返回"处理中"
3. 关闭非核心功能:如关闭评论、关闭推荐
4. 页面静态化:返回CDN缓存的静态页面
5. 拒绝服务:只拒绝低优先级用户
幂等性:同一操作执行一次与执行多次的效果相同。
客户端 ──请求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说明已处理过
<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>
@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));
}
}
@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);
}
}
@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("服务暂时不可用,已记录您的请求");
}
}
@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);
}
}
# application.yml
spring:
cloud:
sentinel:
transport:
dashboard: localhost:8080 # Sentinel控制台地址
port: 8719 # 与控制台通信端口
eager: true # 项目启动即注册
web-context-unify: false # 关闭上下文聚合
http-method-specify: true # 区分HTTP方法
面试官:请你设计一个分布式环境下的限流器,支持每秒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
性能优化:
面试官:线上突然来了一波平时10倍的流量,系统快要扛不住了,你怎么处理?
参考回答(按紧急程度排序):
第一层:紧急止血(1分钟内)
limit_req zone=api burst=50 nodelay;第二层:容量扩展(5分钟内)
第三层:流量调度(10分钟内)
第四层:事后复盘
关键对比点:
要求:实现"IP维度的全局限流 + 用户维度的接口限流"二级限流体系。
// 提示:使用Sentinel的链式规则
// 1. IP维度全局限流 1000 QPS
// 2. 用户维度每接口 50 QPS
// 请补充代码
要求:封装一个@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切面
要求:不依赖任何框架,用Java实现一个简易的CircuitBreaker,包含CLOSED/OPEN/HALF_OPEN三种状态转换。
| 概念 | 核心要点 | 一句话总结 |
|---|---|---|
| 固定窗口 | 简单但有边界突发 | 粗糙但够用 |
| 滑动窗口 | 细粒度格子统计 | 精确限流首选 |
| 令牌桶 | 允许突发,控制平均速率 | API限流标配 |
| 漏桶 | 强制匀速输出 | 流量整形利器 |
| 熔断器 | 三态切换保护系统 | 系统的保险丝 |
| 降级 | 牺牲非核心保核心 | 断臂求生 |
| 幂等 | 同一操作多次结果一致 | 防重复提交的根本 |
下一篇:P4-02-秒杀系统完整实现 → 从0到1搭建完整的秒杀系统