高并发秒杀系统实战（Redis+Lua分布式锁防超卖与库存扣减优化）

// 典型超卖代码示例
@GetMapping("/reduce")
public String reduce() {
    int stock = (Integer) redisTemplate.opsForValue().get("stock");
    if (stock > 0) {
        redisTemplate.opsForValue().set("stock", stock - 1);
        return "秒杀成功";
    }
    return "库存不足";
}

sequenceDiagram
    参与者 用户A as 用户A
    参与者 用户B as 用户B
    参与者 Redis as Redis服务
    
    用户A->>Redis: 查询库存(10)
    用户B->>Redis: 查询库存(10)
    用户A->>Redis: 扣减5个库存(10-5=5)
    用户B->>Redis: 扣减6个库存(5-6=-1)

public class RedisLock {
    private RedisTemplate<String, String> redisTemplate;
    
    public boolean tryLock(String key, String value, long expireTime) {
        return redisTemplate.opsForValue()
                .setIfAbsent(key, value, expireTime, TimeUnit.SECONDS);
    }
    
    public boolean releaseLock(String key, String value) {
        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                           "return redis.call('del', KEYS[1]) " +
                           "else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
        Long result = redisTemplate.execute(redisScript, Collections.singletonList(key), value);
        return result != null && result == 1;
    }
}

sequenceDiagram
    参与者 Client as 客户端
    参与者 Thread as 守护线程
    参与者 Redis as Redis
    
    Client->>Redis: 获取锁(设置30秒过期)
    Client->>Thread: 启动守护线程
    loop 每10秒执行
        Thread->>Redis: 检查锁是否存在
        Redis-->>Thread: 存在
        Thread->>Redis: 重置过期时间(续命)
    end
    Client->>Redis: 任务完成，释放锁
    Client->>Thread: 停止守护线程

private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

public void renewLock(String key, String value, long renewInterval) {
    scheduler.scheduleAtFixedRate(() -> {
        String currentValue = redisTemplate.opsForValue().get(key);
        if (value.equals(currentValue)) {
            redisTemplate.expire(key, 30, TimeUnit.SECONDS);
        }
    }, 0, renewInterval, TimeUnit.SECONDS);
}

-- KEYS[1]: 商品库存key
-- ARGV[1]: 扣减数量
local key = KEYS[1]
local val = tonumber(ARGV[1])

-- 获取当前库存
local stock = tonumber(redis.call('get', key))

if stock <= 0 then
    return -1 -- 库存不足
end

if stock < val then
    return -2 -- 库存不足指定数量
end

-- 扣减库存
local newStock = redis.call('decrby', key, val)

if newStock >= 0 then
    return newStock -- 扣减成功
else
    -- 回滚操作
    redis.call('incrby', key, val)
    return -3 -- 扣减后库存为负，操作回滚
end

@Configuration
public class LuaScriptConfig {
    
    @Bean
    public DefaultRedisScript<Long> stockDeductScript() {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
        script.setLocation(new ClassPathResource("lua/stock_deduct.lua"));
        script.setResultType(Long.class);
        return script;
    }
}

@Service
public class SecKillService {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    @Autowired
    private DefaultRedisScript<Long> stockDeductScript;
    
    public String handleSecKill(String productId, int quantity) {
        List<String> keys = Collections.singletonList("stock:" + productId);
        Long result = redisTemplate.execute(
                stockDeductScript, 
                keys, 
                String.valueOf(quantity));
        
        if (result == -1 || result == -2) {
            return "库存不足";
        } else if (result == -3) {
            return "扣减失败，库存不足";
        }
        
        // 扣减成功，创建订单
        createOrder(productId, quantity);
        return "秒杀成功";
    }
}

// 初始化分段库存
public void initSegmentStock(String productId, int totalStock, int segment) {
    int base = totalStock / segment;
    for (int i = 0; i < segment; i++) {
        int segmentStock = (i == segment - 1) ? 
                base + totalStock % segment : base;
        redisTemplate.opsForValue().set(
                "stock:" + productId + ":" + i, 
                segmentStock);
    }
}

// 分段扣减
public boolean segmentDeduct(String productId, int quantity) {
    int segment = getSegmentCount(productId);
    for (int i = 0; i < segment; i++) {
        String key = "stock:" + productId + ":" + i;
        Long result = redisTemplate.execute(
                stockDeductScript, 
                Collections.singletonList(key), 
                String.valueOf(quantity));
        if (result != null && result >= 0) {
            return true;
        }
    }
    return false;
}

http {
    limit_req_zone $binary_remote_addr zone=secKill:10m rate=100r/s;
    
    server {
        location /seckill {
            limit_req zone=secKill burst=50;
            proxy_pass http://backend_server;
        }
    }
}

public boolean tryAcquire(String key, int max, int timeout) {
    String luaScript = "local current = redis.call('incr', KEYS[1])\n" +
            "if current == 1 then\n" +
            "    redis.call('expire', KEYS[1], ARGV[1])\n" +
            "end\n" +
            "if current > tonumber(ARGV[2]) then\n" +
            "    return 0\n" +
            "else\n" +
            "    return 1\n" +
            "end";
    
    DefaultRedisScript<Long> script = new DefaultRedisScript<>(luaScript, Long.class);
    Long result = redisTemplate.execute(script, 
            Collections.singletonList(key), 
            String.valueOf(timeout), 
            String.valueOf(max));
    return result != null && result == 1;
}

bar
    title 资源消耗对比
    x-axis 方案
    y-axis CPU利用率(%)
    series 数据库悲观锁: 85
    series 应用层锁: 65
    series Redis+Lua: 42
    series 库存分段: 38