撑住流量洪峰！七个 Java 高并发秒杀原则助你轻松扛住双11！

最新推荐文章于 2025-11-27 10:55:11 发布

原创最新推荐文章于 2025-11-27 10:55:11 发布 · 491 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

真正能撑住双 11 流量洪峰的，不是某个单一的优化，而是从前端到数据库的全链路协同设计。当你构建出这样一套体系，面对千万级并发也能做到“系统稳如老狗”，再也不用担心用户抱怨“点了没反应，结果秒没了”。

想象这样一个场景：

午夜零点，某款新手机开放抢购；
数十万人几乎在同一毫秒同时点击“立即购买”；
页面瞬间卡死，支付没反应，库存提示“售罄”；
结果大多数人都没有下单成功，却感觉像被“欺骗”。

这就是 高并发秒杀。它不仅仅是卖货的活动，更是对 系统架构、并发处理、用户体验 的极限考验。

秒杀的本质特点包括：

瞬时高并发：同时涌入的请求可能超过 10 万；
资源极度稀缺：几百件商品要面对几十万的抢购请求；
一致性要求高：不能出现超卖、重复下单；
用户体验敏感：哪怕页面延迟一秒，都会带来大量投诉。

如果没有任何防护，所有请求直冲数据库，结局可想而知：连接池打满、锁竞争、CPU 飙升、事务阻塞、系统崩溃。

那我们该如何从容应对？本文将通过 7 大策略，结合前后端代码实例，为你完整拆解 Java 高并发秒杀的应对方案。

一、前端优化：第一层拦截

前端虽然无法彻底阻止恶意攻击，但却是最接近用户的一层，可以显著减少无效请求涌入后端。

按钮防连点（防误触）

避免用户因手滑或卡顿多次提交请求。

<template>
  <button
    :disabled="isDisabled || countdown > 0"
    @click="handleClick"
    class="seckill-btn"
  >
    {{ buttonText }}
  </button>
</template>


<script>
export default {
  data() {
    return {
      isDisabled: false,
      countdown: 0,
      maxCountdown: 5
    }
  },
  computed: {
    buttonText() {
      if (this.countdown > 0) return `请等待${this.countdown}秒`
      return this.isDisabled ? '抢购中...' : '立即抢购'
    }
  },
  methods: {
    async handleClick() {
      if (this.isDisabled || this.countdown > 0) return
      this.isDisabled = true
      try {
        const result = await this.$api.createOrder()
        if (result.success) {
          this.$message.success('抢购成功')
        } else {
          this.startCountdown()
          this.$message.error(result.message || '抢购失败')
        }
      } catch (e) {
        this.startCountdown()
        this.$message.error('请求异常，请稍后重试')
      } finally {
        this.isDisabled = false
      }
    },
    startCountdown() {
      this.countdown = this.maxCountdown
      const timer = setInterval(() => {
        this.countdown--
        if (this.countdown <= 0) clearInterval(timer)
      }, 1000)
    }
  }
}
</script>

优化点：

请求失败后，按钮进入冷却期，避免用户疯狂点击；
提供友好的提示，降低用户焦虑感。

请求频率限制（节流）

即使前端无法防住所有脚本攻击，节流依然是减少无效请求的有效手段。

function throttle(fn, delay) {
  let lastCall = 0
  return function (...args) {
    const now = Date.now()
    if (now - lastCall < delay) {
      console.warn('操作过于频繁')
      return
    }
    lastCall = now
    return fn.apply(this, args)
  }
}


const throttledCreateOrder = throttle(createOrder, 500) // 500ms 内最多一次

二、后端核心方案：架构护城河

流量削峰：Redis Streams 缓冲队列

直接把上百万请求打到数据库，必死无疑。我们需要 Redis Streams 来作为缓冲器。

路径：/src/main/java/com/icoderoad/seckill/service/SeckillQueueService.java

package com.icoderoad.seckill.service;


@Slf4j
@Service
public class SeckillQueueService {


    @Resource
    private RedisTemplate<String, Object> redisTemplate;


    private static final String STREAM_KEY = "seckill:requests";
    private static final String GROUP = "seckill_group";
    private static final String DLQ_KEY = "seckill:dlq";


    @PostConstruct
    public void initGroup() {
        try {
            redisTemplate.opsForStream().createGroup(STREAM_KEY, ReadOffset.from("0-0"), GROUP);
        } catch (Exception e) {
            log.info("消费者组已存在: {}", GROUP);
        }
    }


    /** 入队：防重复提交 + 写入消息队列 */
    public boolean enqueue(String userId, String productId) {
        String key = "seckill:participated:" + productId;
        if (Boolean.TRUE.equals(redisTemplate.opsForSet().isMember(key, userId))) return false;


        Map<String, Object> msg = Map.of(
            "userId", userId,
            "productId", productId,
            "time", System.currentTimeMillis(),
            "reqId", UUID.randomUUID().toString()
        );


        redisTemplate.opsForStream().add(STREAM_KEY, msg);
        redisTemplate.opsForSet().add(key, userId);
        redisTemplate.expire(key, 10, TimeUnit.MINUTES);
        return true;
    }


    /** 消费请求 */
    @Async("seckillExecutor")
    public void consume() {
        while (true) {
            try {
                List<MapRecord<String, Object, Object>> records = redisTemplate.opsForStream()
                        .read(Consumer.from(GROUP, "c-" + Thread.currentThread().getId()),
                              StreamReadOptions.empty().count(1).block(Duration.ofSeconds(5)),
                              StreamOffset.create(STREAM_KEY, ReadOffset.lastConsumed()));


                if (records == null) continue;


                for (MapRecord<String, Object, Object> rec : records) {
                    Map<Object, Object> body = rec.getValue();
                    String uid = (String) body.get("userId");
                    String pid = (String) body.get("productId");


                    if (process(uid, pid)) {
                        redisTemplate.opsForStream().acknowledge(STREAM_KEY, GROUP, rec.getId());
                    } else {
                        redisTemplate.opsForList().leftPush(DLQ_KEY, body);
                    }
                }
            } catch (Exception e) {
                log.error("消费异常", e);
                try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
            }
        }
    }


    private boolean process(String uid, String pid) {
        if (reduceStock(pid, 1)) {
            createOrder(uid, pid);
            return true;
        }
        return false;
    }


    private boolean reduceStock(String pid, int count) {
        // Redis Lua 扣减逻辑
        return true;
    }


    private void createOrder(String uid, String pid) {
        log.info("订单创建成功：user={} product={}", uid, pid);
    }
}

优化点：

使用 DLQ 死信队列保存失败请求，便于人工干预；
异步消费，平滑处理请求；
结合 Redis ACK 机制，保证消息可靠。

三、防超卖：Redis + Lua 原子扣减

路径：/src/main/java/com/icoderoad/seckill/service/StockService.java

核心逻辑：检查库存 + 扣减 必须是一个原子操作，否则会导致超卖。

@Service
@Slf4j
public class StockService {


    @Resource
    private RedisTemplate<String, Object> redisTemplate;


    private static final String LUA_SCRIPT =
        "local stock = redis.call('get', KEYS[1]) " +
        "if not stock then return 0 " +
        "elseif tonumber(stock) < tonumber(ARGV[1]) then return 0 " +
        "else redis.call('decrby', KEYS[1], ARGV[1]) return 1 end";


    public boolean reduceStock(String productId, int qty) {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(LUA_SCRIPT, Long.class);
        Long res = redisTemplate.execute(script, List.of("product:stock:" + productId), String.valueOf(qty));
        return res != null && res == 1L;
    }


    public void preloadStock(String productId, int stock) {
        redisTemplate.opsForValue().set("product:stock:" + productId, stock);
    }


    public void syncStockToDB(String productId, int finalStock) {
        // 批量写回 MySQL，避免频繁 I/O
        log.info("库存同步至DB product={} stock={}", productId, finalStock);
    }
}