以下是几种Java实现超买超卖问题的核心解决方案及代码示例，针对高并发场景下的库存扣减问题：

方案一：Redis原子操作 + Lua脚本（推荐）

// 使用Redis+Lua保证原子性
public boolean deductStock(String productId, int quantity) {
    String luaScript = 
        "local stock = tonumber(redis.call('get', KEYS[1])) " +
        "if stock >= tonumber(ARGV[1]) then " +
        "   redis.call('decrby', KEYS[1], ARGV[1]) " +
        "   return 1 " +
        "else " +
        "   return 0 " +
        "end";
    
    Long result = jedis.eval(
        luaScript, 
        Collections.singletonList("stock:" + productId), 
        Collections.singletonList(String.valueOf(quantity))
    );
    return result == 1;
}

优势：

1. 原子操作避免超卖
2. 性能可达10万+ QPS
3. 无需分布式锁

方案二：数据库乐观锁

// 基于版本号的乐观锁实现
@Transactional
public boolean deductStock(Long productId, int quantity) {
    Product product = productDao.selectForUpdate(productId);
    if (product.getStock() >= quantity) {
        int rows = productDao.updateStock(
            productId, 
            quantity, 
            product.getVersion()  // 携带版本号
        );
        return rows > 0;  // 更新成功返回true
    }
    return false;
}

// SQL示例
UPDATE product 
SET stock = stock - #{quantity}, 
    version = version + 1 
WHERE id = #{id} 
  AND version = #{oldVersion} 
  AND stock >= #{quantity}

方案三：令牌桶限流 + Redis分布式锁

// 令牌桶限流（Guava RateLimiter）
private final RateLimiter rateLimiter = RateLimiter.create(1000); // 每秒1000个请求

public boolean purchase(Long productId, int quantity) {
    if (!rateLimiter.tryAcquire()) {
        throw new RuntimeException("系统繁忙");
    }
    
    String lockKey = "lock:product:" + productId;
    try {
        // 获取分布式锁（Redisson实现）
        RLock lock = redissonClient.getLock(lockKey);
        if (lock.tryLock(100, 10, TimeUnit.MILLISECONDS)) {
            // 执行库存扣减
            return doDeductStock(productId, quantity);
        }
    } finally {
        lock.unlock();
    }
    return false;
}

方案四：消息队列异步处理

// RocketMQ实现削峰填谷
public void handlePurchase(PurchaseRequest request) {
    // 1. 快速校验基础库存
    if (redisTemplate.opsForValue().decrement(
            "prestock:" + request.getProductId(), 
            request.getQuantity()) >= 0) {
        
        // 2. 发送消息到队列
        rocketMQTemplate.send("order_topic", 
            MessageBuilder.withPayload(request).build()
        );
    }
}

// 消费者端
@RocketMQMessageListener(topic = "order_topic", consumerGroup = "order_group")
public class OrderConsumer implements RocketMQListener<PurchaseRequest> {
    @Override
    public void onMessage(PurchaseRequest request) {
        // 3. 执行数据库库存扣减
        deductStockInDB(request);
    }
}

方案五：分桶库存策略

// 将库存拆分为多个桶
public boolean deductStock(Long productId, int quantity) {
    String bucketKey = getAvailableBucket(productId); // 路由到某个桶
    Long remain = redisTemplate.opsForValue().decrement(bucketKey, quantity);
    
    if (remain != null && remain >= 0) {
        return true;
    } else {
        // 桶库存不足时回滚
        redisTemplate.opsForValue().increment(bucketKey, quantity);
        return false;
    }
}

// 初始化10个库存桶
public void initStockBuckets(Long productId, int totalStock) {
    int bucketSize = 10;
    int stockPerBucket = totalStock / bucketSize;
    for (int i=0; i<bucketSize; i++) {
        redisTemplate.opsForValue().set(
            "stock:" + productId + ":bucket" + i,
            stockPerBucket
        );
    }
}

选择建议：

1. 超高并发场景：Redis Lua + 令牌桶限流
2. 强一致性需求：数据库乐观锁 + 重试机制
3. 流量削峰：消息队列异步处理
4. 热点商品：分桶库存策略
5. 分布式环境：Redisson分布式锁

性能对比：

Redis方案：10万+ QPS

数据库方案：~2000 QPS

消息队列：取决于消费者数量