<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 `請(qǐng)等待${this.countdown}秒`
      return this.isDisabled ? '搶購(gòu)中...' : '立即搶購(gòu)'
    }
  },
  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('搶購(gòu)成功')
        } else {
          this.startCountdown()
          this.$message.error(result.message || '搶購(gòu)失敗')
        }
      } catch (e) {
        this.startCountdown()
        this.$message.error('請(qǐng)求異常，請(qǐng)稍后重試')
      } 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 內(nèi)最多一次

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("消費(fèi)者組已存在: {}", GROUP);
        }
    }


    /** 入隊(duì)：防重復(fù)提交 + 寫入消息隊(duì)列 */
    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;
    }


    /** 消費(fèi)請(qǐng)求 */
    @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("消費(fèi)異常", 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("訂單創(chuàng)建成功：user={} product={}", uid, pid);
    }
}

@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("庫(kù)存同步至DB product={} stock={}", productId, finalStock);
    }
}