🎓博主介绍：Java、Python、js全栈开发 “多面手”，精通多种编程语言和技术，痴迷于人工智能领域。秉持着对技术的热爱与执着，持续探索创新，愿在此分享交流和学习，与大家共进步。
📖DeepSeek-行业融合之万象视界(附实战案例详解100+)
📖全栈开发环境搭建运行攻略：多语言一站式指南(环境搭建+运行+调试+发布+保姆级详解)
👉感兴趣的可以先收藏起来，希望帮助更多的人

SpringBoot电商项目实战：高并发场景下的库存扣减方案

一、引言

在电商项目中，库存管理是一个核心功能，而库存扣减则是其中最为关键的操作之一。特别是在高并发场景下，如电商大促活动时，大量用户同时下单，对库存进行扣减操作，如果处理不当，就会出现超卖等严重问题。本文将基于SpringBoot框架，详细探讨高并发场景下的库存扣减方案。

二、常见库存扣减问题分析

2.1 超卖问题

超卖是指在库存不足的情况下，仍然成功处理了订单，导致实际发货数量超过了库存数量。这通常是由于并发操作时，多个线程同时读取到相同的库存数量，然后都进行扣减操作，从而造成库存变为负数的情况。

2.2 数据不一致问题

在高并发场景下，由于数据库事务的隔离级别、缓存与数据库数据同步等问题，可能会导致库存数据在不同节点或不同时刻出现不一致的情况。

2.3 性能瓶颈问题

频繁的库存扣减操作会对数据库造成较大的压力，导致数据库性能下降，从而影响整个系统的响应速度和吞吐量。

三、库存扣减方案选择

3.1 数据库乐观锁方案

乐观锁是一种基于版本号或时间戳的并发控制机制，它假设在大多数情况下，并发操作不会发生冲突，因此在更新数据时，先检查数据的版本号是否与读取时一致，如果一致则进行更新，否则认为数据已经被其他线程修改，需要重新读取数据进行操作。

以下是使用SpringBoot和MyBatis实现数据库乐观锁的示例代码：

3.1.1 数据库表设计

CREATE TABLE product_stock (
    id INT PRIMARY KEY AUTO_INCREMENT,
    product_id INT NOT NULL,
    stock INT NOT NULL,
    version INT NOT NULL DEFAULT 0
);

3.1.2 实体类定义

public class ProductStock {
    private Integer id;
    private Integer productId;
    private Integer stock;
    private Integer version;

    // 省略getter和setter方法
}

3.1.3 Mapper接口

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface ProductStockMapper {
    ProductStock getStockByProductId(@Param("productId") Integer productId);

    int updateStock(@Param("productId") Integer productId, @Param("quantity") Integer quantity, @Param("version") Integer version);
}

3.1.4 Mapper XML文件

<mapper namespace="com.example.mapper.ProductStockMapper">
    <select id="getStockByProductId" resultType="com.example.entity.ProductStock">
        SELECT * FROM product_stock WHERE product_id = #{productId}
    </select>
    <update id="updateStock">
        UPDATE product_stock
        SET stock = stock - #{quantity}, version = version + 1
        WHERE product_id = #{productId} AND version = #{version}
    </update>
</mapper>

3.1.5 服务层代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ProductStockService {
    @Autowired
    private ProductStockMapper productStockMapper;

    public boolean reduceStock(Integer productId, Integer quantity) {
        ProductStock stock = productStockMapper.getStockByProductId(productId);
        if (stock == null || stock.getStock() < quantity) {
            return false;
        }
        int rows = productStockMapper.updateStock(productId, quantity, stock.getVersion());
        return rows > 0;
    }
}

3.2 数据库悲观锁方案

悲观锁是一种基于数据库的锁机制，它假设在大多数情况下，并发操作会发生冲突，因此在读取数据时就对数据进行加锁，防止其他线程同时修改数据。在MySQL中，可以使用SELECT ... FOR UPDATE语句来实现悲观锁。

以下是使用SpringBoot和MyBatis实现数据库悲观锁的示例代码：

3.2.1 Mapper接口

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface ProductStockMapper {
    ProductStock getStockByProductIdForUpdate(@Param("productId") Integer productId);

    int updateStock(@Param("productId") Integer productId, @Param("quantity") Integer quantity);
}

3.2.2 Mapper XML文件

<mapper namespace="com.example.mapper.ProductStockMapper">
    <select id="getStockByProductIdForUpdate" resultType="com.example.entity.ProductStock">
        SELECT * FROM product_stock WHERE product_id = #{productId} FOR UPDATE
    </select>
    <update id="updateStock">
        UPDATE product_stock
        SET stock = stock - #{quantity}
        WHERE product_id = #{productId}
    </update>
</mapper>

3.2.3 服务层代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ProductStockService {
    @Autowired
    private ProductStockMapper productStockMapper;

    @Transactional
    public boolean reduceStock(Integer productId, Integer quantity) {
        ProductStock stock = productStockMapper.getStockByProductIdForUpdate(productId);
        if (stock == null || stock.getStock() < quantity) {
            return false;
        }
        int rows = productStockMapper.updateStock(productId, quantity);
        return rows > 0;
    }
}

3.3 Redis缓存方案

Redis是一种高性能的内存数据库，它支持原子操作，可以在高并发场景下快速处理库存扣减操作。可以使用Redis的decrby命令来实现库存扣减。

以下是使用SpringBoot和RedisTemplate实现Redis缓存方案的示例代码：

3.3.1 Redis配置

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

3.3.2 服务层代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class ProductStockService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public boolean reduceStock(String productId, Integer quantity) {
        String key = "product_stock:" + productId;
        Long stock = redisTemplate.opsForValue().decrement(key, quantity);
        return stock != null && stock >= 0;
    }
}

四、方案对比与选择建议

4.1 数据库乐观锁方案

• 优点：实现简单，对数据库性能影响较小，适用于并发冲突较少的场景。
• 缺点：当并发冲突较多时，会出现大量的重试操作，影响系统性能。
• 选择建议：适用于并发量不是特别大，对数据一致性要求较高的场景。

4.2 数据库悲观锁方案

• 优点：可以有效避免并发冲突，保证数据的一致性。
• 缺点：对数据库性能影响较大，会导致其他线程长时间等待锁，降低系统的并发处理能力。
• 选择建议：适用于并发量较大，对数据一致性要求极高的场景。

4.3 Redis缓存方案

• 优点：性能高，能够快速处理大量的并发请求，减轻数据库压力。
• 缺点：数据存在一定的一致性风险，需要定期与数据库进行同步。
• 选择建议：适用于并发量非常大，对性能要求极高的场景。

五、高并发场景下的优化策略

5.1 限流

限流是指对系统的请求流量进行限制，防止过多的请求涌入系统，导致系统崩溃。可以使用令牌桶算法或漏桶算法来实现限流。

以下是使用Guava RateLimiter实现限流的示例代码：

import com.google.common.util.concurrent.RateLimiter;
import org.springframework.stereotype.Service;

@Service
public class RateLimitService {
    private final RateLimiter rateLimiter = RateLimiter.create(100); // 每秒允许100个请求

    public boolean tryAcquire() {
        return rateLimiter.tryAcquire();
    }
}

5.2 异步处理

将库存扣减操作异步化，使用消息队列（如RabbitMQ、Kafka）来处理库存扣减任务，减轻主线程的压力，提高系统的并发处理能力。

以下是使用Spring Boot和RabbitMQ实现异步处理的示例代码：

5.2.1 配置类

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {
    @Bean
    public Queue stockQueue() {
        return new Queue("stock_queue");
    }
}

5.2.2 生产者代码

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class StockMessageProducer {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend("stock_queue", message);
    }
}

5.2.3 消费者代码

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

@Service
public class StockMessageConsumer {
    @RabbitListener(queues = "stock_queue")
    public void receiveMessage(String message) {
        // 处理库存扣减逻辑
    }
}

5.3 缓存预热

在系统启动时，将热门商品的库存数据加载到Redis缓存中，减少对数据库的访问，提高系统的响应速度。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

@Service
public class CachePreheatService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @PostConstruct
    public void preheatCache() {
        Map<String, Integer> stockMap = new HashMap<>();
        // 模拟从数据库中获取热门商品的库存数据
        stockMap.put("product_1", 100);
        stockMap.put("product_2", 200);
        for (Map.Entry<String, Integer> entry : stockMap.entrySet()) {
            String key = "product_stock:" + entry.getKey();
            redisTemplate.opsForValue().set(key, entry.getValue());
        }
    }
}

六、总结

在高并发场景下，库存扣减是电商项目中一个极具挑战性的问题。本文详细介绍了数据库乐观锁、数据库悲观锁和Redis缓存三种常见的库存扣减方案，并对它们进行了对比和选择建议。同时，还介绍了限流、异步处理和缓存预热等优化策略，以提高系统的性能和稳定性。在实际项目中，需要根据具体的业务场景和需求，选择合适的库存扣减方案和优化策略，以确保系统的正确性和高效性。