适用对象:5年经验Java开发者,目标薪资18-22K
课时:约4小时 | 理论30% + 实战40% + 面试20% + 练习10%
秒杀场景的三大核心问题:
┌─────────────────────────────────────────────────────────┐
│ Layer 1: 客户端层 │
│ ├── 页面静态化(CDN缓存) │
│ ├── 按钮置灰 + 倒计时 │
│ └── 答题/验证码防机器 │
├─────────────────────────────────────────────────────────┤
│ Layer 2: Nginx层 │
│ ├── 限流(limit_req) │
│ ├── IP黑名单 │
│ └── 静态资源缓存 │
├─────────────────────────────────────────────────────────┤
│ Layer 3: 网关层(Gateway) │
│ ├── 全局限流(Sentinel) │
│ ├── 用户维度的请求频率限制 │
│ └── 秒杀活动状态校验(是否开始/结束) │
├─────────────────────────────────────────────────────────┤
│ Layer 4: 应用层 │
│ ├── 幂等Token校验 │
│ ├── Redis Lua原子扣库存 │
│ └── MQ异步下单 │
├─────────────────────────────────────────────────────────┤
│ Layer 5: 消息队列层 │
│ ├── 流量削峰 │
│ ├── 顺序消费保证 │
│ └── 消费失败重试 + 死信队列 │
├─────────────────────────────────────────────────────────┤
│ Layer 6: 数据层 │
│ ├── 数据库乐观锁/悲观锁 │
│ ├── Redis集群(缓存 + 分布式锁) │
│ └── 最终库存对账 │
└─────────────────────────────────────────────────────────┘
用户 → CDN(静态页) → Nginx(限流) → Gateway(鉴权+限流)
→ App(幂等校验) → Redis Lua(原子扣库存)
→ RocketMQ(异步下单) → Consumer(创建订单+扣DB库存)
→ WebSocket(推送结果)
-- seckill_deduct_stock.lua
-- KEYS[1] = 秒杀库存key seckill:stock:{activityId}
-- KEYS[2] = 已购买用户集合key seckill:bought:{activityId}
-- ARGV[1] = 用户ID
-- ARGV[2] = 活动ID
local stockKey = KEYS[1]
local boughtKey = KEYS[2]
local userId = ARGV[1]
local activityId = ARGV[2]
-- 1. 检查用户是否已购买(防重复购买)
local isBought = redis.call('SISMEMBER', boughtKey, userId)
if isBought == 1 then
return -2 -- 已购买过
end
-- 2. 获取当前库存
local stock = tonumber(redis.call('GET', stockKey))
if stock == nil then
return -3 -- 活动不存在
end
-- 3. 判断库存是否充足
if stock <= 0 then
return 0 -- 库存不足
end
-- 4. 原子操作:扣库存 + 记录用户
redis.call('DECR', stockKey)
redis.call('SADD', boughtKey, userId)
-- 5. 设置过期时间(活动结束后自动清理)
redis.call('EXPIRE', boughtKey, 86400)
return 1 -- 扣减成功
@Service
@Slf4j
public class SeckillService {
@Autowired
private StringRedisTemplate redisTemplate;
@Autowired
private RedissonClient redissonClient;
@Autowired
private RocketMQTemplate rocketMQTemplate;
private static final String STOCK_KEY = "seckill:stock:";
private static final String BOUGHT_KEY = "seckill:bought:";
private static final String ACTIVITY_KEY = "seckill:activity:";
// Lua脚本(项目启动时加载)
private DefaultRedisScript<Long> deductStockScript;
@PostConstruct
public void init() {
deductStockScript = new DefaultRedisScript<>();
deductStockScript.setLocation(
new ClassPathResource("lua/seckill_deduct_stock.lua"));
deductStockScript.setResultType(Long.class);
}
/**
* 秒杀核心接口
*/
@SentinelResource(value = "seckill.execute",
blockHandler = "seckillBlockHandler",
fallback = "seckillFallback")
public SeckillResult execute(Long userId, Long activityId, String token) {
// ====== 第一关:活动状态校验 ======
String activityInfo = redisTemplate.opsForValue()
.get(ACTIVITY_KEY + activityId);
if (activityInfo == null) {
return SeckillResult.fail("活动不存在");
}
SeckillActivity activity = JSON.parseObject(activityInfo,
SeckillActivity.class);
long now = System.currentTimeMillis();
if (now < activity.getStartTime().getTime()) {
return SeckillResult.fail("活动未开始");
}
if (now > activity.getEndTime().getTime()) {
return SeckillResult.fail("活动已结束");
}
// ====== 第二关:幂等Token校验 ======
String tokenKey = "seckill:token:" + userId + ":" + activityId;
Boolean valid = redisTemplate.delete(tokenKey);
if (valid == null || !valid) {
return SeckillResult.fail("请勿重复提交");
}
// ====== 第三关:Redis Lua原子扣库存 ======
Long result = redisTemplate.execute(
deductStockScript,
Arrays.asList(STOCK_KEY + activityId, BOUGHT_KEY + activityId),
userId.toString(),
activityId.toString()
);
if (result == null) {
return SeckillResult.fail("系统异常");
}
if (result == -2) {
return SeckillResult.fail("您已购买过该商品");
}
if (result == -3) {
return SeckillResult.fail("活动不存在");
}
if (result == 0) {
return SeckillResult.fail("商品已售罄");
}
// ====== 第四关:发送MQ消息异步创建订单 ======
SeckillMessage message = new SeckillMessage();
message.setUserId(userId);
message.setActivityId(activityId);
message.setProductId(activity.getProductId());
message.setPrice(activity.getSeckillPrice());
message.setOrderNo(generateOrderNo());
message.setTimestamp(now);
try {
rocketMQTemplate.syncSend(
"seckill-order-topic",
MessageBuilder.withPayload(message)
.setKeys(message.getOrderNo())
.build(),
3000, // 超时3秒
0 // 延迟级别0=不延迟
);
} catch (Exception e) {
// MQ发送失败,回滚Redis库存
redisTemplate.opsForValue().increment(STOCK_KEY + activityId);
redisTemplate.opsForSet().remove(BOUGHT_KEY + activityId,
userId.toString());
log.error("MQ发送失败,库存已回滚: userId={}, activityId={}",
userId, activityId, e);
return SeckillResult.fail("系统繁忙,请稍后重试");
}
log.info("秒杀成功,等待订单创建: userId={}, activityId={}, orderNo={}",
userId, activityId, message.getOrderNo());
return SeckillResult.success(message.getOrderNo());
}
private String generateOrderNo() {
return "SK" + IdWorker.getIdStr();
}
// Sentinel限流处理
public SeckillResult seckillBlockHandler(Long userId, Long activityId,
String token, BlockException ex) {
return SeckillResult.fail("当前参与人数过多,请稍后重试");
}
// 业务异常降级
public SeckillResult seckillFallback(Long userId, Long activityId,
String token, Throwable t) {
log.error("秒杀异常: userId={}", userId, t);
return SeckillResult.fail("系统异常,请稍后重试");
}
}
@Component
@RocketMQMessageListener(
topic = "seckill-order-topic",
consumerGroup = "seckill-order-consumer-group",
selectorExpression = "*"
)
@Slf4j
public class SeckillOrderConsumer implements RocketMQListener<SeckillMessage> {
@Autowired
private OrderService orderService;
@Autowired
private RedissonClient redissonClient;
@Autowired
private StringRedisTemplate redisTemplate;
@Override
public void onMessage(SeckillMessage message) {
log.info("收到秒杀订单消息: {}", message);
// 分布式锁防止重复消费
String lockKey = "seckill:lock:" + message.getOrderNo();
RLock lock = redissonClient.getLock(lockKey);
try {
boolean locked = lock.tryLock(5, 30, TimeUnit.SECONDS);
if (!locked) {
log.warn("获取分布式锁失败,可能重复消费: {}",
message.getOrderNo());
return;
}
// 幂等校验:检查订单是否已创建
Boolean orderExists = redisTemplate.hasKey(
"seckill:order:" + message.getOrderNo());
if (Boolean.TRUE.equals(orderExists)) {
log.info("订单已创建,跳过: {}", message.getOrderNo());
return;
}
// 创建订单(数据库操作)
Order order = orderService.createSeckillOrder(
message.getUserId(),
message.getProductId(),
message.getPrice(),
message.getOrderNo()
);
// 标记订单已创建
redisTemplate.opsForValue().set(
"seckill:order:" + message.getOrderNo(),
JSON.toJSONString(order),
24, TimeUnit.HOURS
);
// TODO: 通过WebSocket通知用户订单创建成功
log.info("秒杀订单创建成功: orderNo={}", message.getOrderNo());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
}
@Component
public class DistributedLockHelper {
@Autowired
private RedissonClient redissonClient;
/**
* 执行带分布式锁的操作
* @param lockKey 锁的key
* @param waitTime 等待时间(秒)
* @param leaseTime 持有时间(秒)
* @param action 要执行的操作
*/
public <T> T executeWithLock(String lockKey, long waitTime,
long leaseTime, Supplier<T> action) {
RLock lock = redissonClient.getLock(lockKey);
try {
boolean locked = lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
if (!locked) {
throw new BusinessException("获取锁失败,请稍后重试");
}
return action.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new BusinessException("操作被中断");
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
}
@Mapper
public interface SeckillStockMapper {
/**
* 乐观锁扣减库存
* 利用stock > 0作为条件,防止超卖
*/
@Update("UPDATE seckill_stock SET stock = stock - #{quantity}, " +
"version = version + 1 " +
"WHERE activity_id = #{activityId} " +
"AND stock >= #{quantity}")
int deductStock(@Param("activityId") Long activityId,
@Param("quantity") Integer quantity);
}
@Service
@Slf4j
public class SeckillPreheatService {
@Autowired
private SeckillActivityMapper activityMapper;
@Autowired
private StringRedisTemplate redisTemplate;
/**
* 活动开始前预热库存到Redis
*/
@Scheduled(cron = "0 */5 * * * ?") // 每5分钟检查
public void preheatStock() {
List<SeckillActivity> activities = activityMapper
.selectUpcoming(LocalDateTime.now().plusHours(1));
for (SeckillActivity activity : activities) {
String stockKey = "seckill:stock:" + activity.getId();
String activityKey = "seckill:activity:" + activity.getId();
// 缓存库存
redisTemplate.opsForValue().setIfAbsent(
stockKey,
String.valueOf(activity.getTotalStock()),
24, TimeUnit.HOURS
);
// 缓存活动信息
redisTemplate.opsForValue().set(
activityKey,
JSON.toJSONString(activity),
24, TimeUnit.HOURS
);
log.info("活动预热完成: activityId={}, stock={}",
activity.getId(), activity.getTotalStock());
}
}
}
@RestController
@RequestMapping("/api/seckill")
public class SeckillController {
@Autowired
private StringRedisTemplate redisTemplate;
@Autowired
private SeckillService seckillService;
/**
* 获取秒杀Token(前端在秒杀开始前调用)
*/
@GetMapping("/token/{activityId}")
public Result<String> getToken(
@PathVariable Long activityId,
@RequestParam Long userId) {
// 校验活动状态
String activityJson = redisTemplate.opsForValue()
.get("seckill:activity:" + activityId);
if (activityJson == null) {
return Result.fail("活动不存在");
}
// 生成Token
String token = IdWorker.getIdStr();
String tokenKey = "seckill:token:" + userId + ":" + activityId;
// 每人每活动只能获取一个Token,有效期5分钟
Boolean set = redisTemplate.opsForValue()
.setIfAbsent(tokenKey, token, 5, TimeUnit.MINUTES);
if (Boolean.FALSE.equals(set)) {
return Result.fail("请勿频繁获取Token");
}
return Result.success(token);
}
/**
* 执行秒杀
*/
@PostMapping("/execute")
public Result<SeckillResult> execute(
@RequestBody SeckillRequest request) {
SeckillResult result = seckillService.execute(
request.getUserId(),
request.getActivityId(),
request.getToken()
);
return Result.success(result);
}
}
面试官:秒杀场景下如何绝对防止超卖?
分层回答:
Redis层(第一道防线):
数据库层(最终防线):
UPDATE stock = stock - 1 WHERE stock > 0对账机制(兜底):
关键代码:
-- 这条SQL就是防超卖的根本保证
UPDATE seckill_stock SET stock = stock - 1
WHERE activity_id = 100 AND stock > 0;
-- 影响行数为0 → 库存已空,不超卖
面试官:秒杀开始的瞬间有100万用户同时点击,你怎么扛住?
回答结构:
1. CDN层:秒杀页面全部静态化,JS/CSS/图片走CDN,请求根本不到后端
2. 按钮策略:前端按钮点击后置灰3秒 + 随机散列(加入随机延迟1-3秒),打散请求
3. Nginx限流:limit_req zone=seckill burst=100 nodelay;,直接丢弃超限请求
4. 网关层:Sentinel集群限流,多节点共享配额
5. Redis预扣:Lua脚本微秒级处理,不经过任何数据库
6. MQ削峰:扣完库存后直接返回"排队中",实际订单创建走MQ异步
核心思想:层层过滤,最终到达数据库的请求只是库存数量的量级。
这是一个典型的分布式一致性问题。
方案:
1. MQ发送失败时立即回滚Redis库存(increment + sadd移除)
2. 引入本地消息表:扣库存成功后先写本地消息表,定时任务补偿发送
3. RocketMQ事务消息:先发半消息,扣库存成功后提交,失败则回滚
请补充以下缺失代码:实现一个完整的秒杀活动从创建到结束的流程。
要求:
1. 管理后台创建秒杀活动 → 写DB + 预热Redis
2. 用户获取Token → 执行秒杀 → 查询结果
3. 活动结束 → 库存对账 → 清理Redis缓存
实现基于IP + 用户ID + 设备指纹的三维防刷机制。
// 提示:使用Redis HyperLogLog统计唯一访问
// IP维度:同一IP每秒最多5次
// 用户维度:同一用户每秒最多3次
// 设备维度:同一设备每分钟最多10次
为秒杀系统设计一个JMeter压测方案。
要求:
1. 模拟10000并发用户
2. 思考时间(随机延迟0-5秒)
3. 断言:成功率>99%、RT<500ms
4. 监控指标:CPU、内存、Redis命中率、MQ堆积
| 层级 | 技术 | 作用 |
|---|---|---|
| CDN | 静态资源 | 隔离99%的读流量 |
| Nginx | limit_req | 第一道限流 |
| Gateway | Sentinel | 集群限流 + 鉴权 |
| 应用层 | Lua脚本 | 原子扣库存 |
| MQ | RocketMQ | 异步削峰 |
| DB | 乐观锁 | 最终防超卖 |
上一篇:P4-01-高并发系统设计方法论
下一篇:P4-03-分布式事务实战