订单减库存 java_高并发场景-订单库存防止超卖

本文探讨了电商系统中防止订单超卖的解决方案,包括使用Redis的原子性操作、分布式锁和乐观锁。通过设置Redis分布式锁防止重复下单,利用Redis的increment操作和SQL乐观锁确保库存安全扣减,减少数据库访问,提高并发处理效率。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

背景

在电商系统中买商品过程,先加入购物车,然后选中商品,点击结算,即会进入待支付状态,后续支付。

过程需要检验库存是否足够,保证库存不被超卖。

场景一:买家需要购买数量可以多件

场景二:秒杀活动,到时间点只能购买一件

目的

防止相同用户重复下单

检查库存准确数量

防止扣错库存数量

扣库存时性能效率提升、不阻塞用户

点赞再看,关注公众号:【地藏思维】给大家分享互联网场景设计与架构设计方案

掘金:地藏Kelvin https://juejin.im/user/5d67da8d6fb9a06aff5e85f7

主要解决手段

利用redis的incr、decr的原子性做操作

redis的lpush、rpop的原子性做操作,但是这个只能一个一个的扣,但不能原子地同时扣多个

sql乐观锁

交互流程

b1056d268d2898e0a83ec36f853450ff.png

主要环节:购物车->结清->支付

本文讲述结清时,扣库存环节,分布式系统产生订单环节后续文章再详细分析。

一、防止重复

利用redis分布式锁

用分布式锁,是为了防刷、防止同一个用户同一秒里面把购物车里的商品进行多次结算,防止前端代码出问题触发两次。

利用Jedis客户端编写分布式锁

String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);

lockKey是redis的Key,为用户id+商品id+商品数量组成,这样同一秒中只能有一次处理逻辑。

requestId是redis的value,实际是当前线程id,表示有一条线程占用。

大家要注意这种分布式锁写法,是同时设定超时时间的。有些分布式锁的文章可能是比较旧版的redis不支持同时设置超时时间,他就一条语句先设置key value,另一条语句后设置超时时间。所以大家留意一下。

二、扣减库存

安全扣减库存方案有很多说法,列一下几个方案和我推荐的方案。

方案一:分布式锁

有的文章会用redis分布式锁来做保证扣库存数量准确的环节,让点击结算时,后端逻辑会查询库存和扣库存的update语句同时只有一条线程能够执行,以商品id为分布式锁的key,锁一个商品。但是这样,其他购买相同商品的用户将会进行等待。

优点:这样做虽然安全

缺点:但是失去的是性能问题。

方案二:分布式锁+分段缓存

也有文章会说借鉴ConcurrenthashMap,分段锁的机制,把100个商品,分在3个段上,key为分段名字,value为库存数量。用户下单时对用户id进行%3计算,看落在哪个redis的key上,就去取哪个。

如key1=product-01,value1=33;key2=product-02,value2=33;key3=product-03,value3=33;

其实会有几个问题:

一个是用户想买34件的时候,要去两个片查

一个片上卖完了为0,又要去另外一个片查

取余方式计算每一片数量,除不尽时,让最后一片补,如100/3=33.33。

缺点:

方案复杂

有遗留问题

方案三: redis的lpush rpop

redis队列的lpush、rpop都是只能每次进出一个,对于购买多个数量的情况下不适用,只适用于秒杀情况购买一个的场景、或者抢红包的场景,所以觉得不是很通用。

备注:这个抢红包场景以后再分享。

方案四:推荐使用redis原子操作+sql乐观锁

利用Redis increment 的原子操作,保证库存数安全

先查询redis中是否有库存信息,如果没有就去数据库查,这样就可以减少访问数据库的次数。

获取到后把数值填入redis,以商品id为key,数量为value。

注意要设置序列化方式为StringRedisSerializer,不然不能把value做加减操作。

还需要设置redis对应这个key的超时时间,以防所有商品库存数据都在redis中。

比较下单数量的大小,如果够就做后续逻辑。

执行redis客户端的increment,参数为负数,则做减法。因为redis是单线程处理,并且因为increment让key对应的value 减少后返回的是修改后的值。

有的人会不做第一步查询直接减,其实这样不太好,因为当库存为1时,很多做减3,或者减30情况,其实都是不够,这样就白减。

扣减数据库的库存,这个时候就不需要再select查询,直接乐观锁update,把库存字段值减1 。

做完扣库存就在订单系统做下单。

样例场景:

假设两个用户在第一步查询得到库存等于10,A用户走到第二步扣10件,同时一秒内B用户走到第二部扣3件。

因为redis单线程处理,若A用户线程先执行redis语句,那么现在库存等于0,B就只能失败,就不会出更新数据库了。

public void order(OrderReq req) {

String key = "product:" + req.getProductId();

// 第一步:先检查 库存是否充足

Integer num = (Integer) redisTemplate.get(key);

if (num == null){

// 去查数据库的数据

// 并且把数据库的库存set进redis,注意使用NX参数表示只有当没有redis中没有这个key的时候才set库存数量到redis

//注意要设置序列化方式为StringRedisSerializer,不然不能把value做加减操作

// 同时设置超时时间,因为不能让redis存着所有商品的库存数,以免占用内存。

if (count >=0) {

//设置有效期十分钟

redisTemplate.expire(key, 60*10+随机数防止雪崩, TimeUnit.SECONDS);

}

// 减少经常访问数据库,因为磁盘比内存访问速度要慢

}

if (num < req.getNum()) {

logger.info("库存不足");

}

// 第二步:减少库存

long value = redisTemplate.increment(key, -req.getNum().longValue());

// 库存充足

if (value >= 0) {

logger.info("成功购买");

// update 数据库中商品库存和订单系统下单,单的状态未待支付

// 分开两个系统处理时,可以用LCN做分布式事务,但是也是有概率会订单系统的网络超时

// 也可以使用最终一致性的方式,更新库存成功后,发送mq,等待订单创建生成回调。

boolean res= updateProduct(req);

if (res)

createOrder(req);

} else {

// 减了后小小于0 ,如两个人同时买这个商品,导致A人第一步时看到还有10个库存,但是B人买9个先处理完逻辑,

// 导致B人的线程10-9=1, A人的线程1-10=-9,则现在需要增加刚刚减去的库存,让别人可以买1个

redisTemplate.increment(key, req.getNum().longValue());

logger.info("恢复redis库存");

}

}

update使用乐观锁

updateProduct方法中执行的sql如下:

update Product set count = count - #{购买数量} where id = #{id} and count - #{购买数量} >= 0;

虽然redis已经防止了超卖,但是数据库层面,为了也要防止超卖,以防redis崩溃时无法使用或者不需要redis处理时,则用乐观锁,因为不一定全部商品都用redis。

利用sql每条单条语句都是有事务的,所以两条sql同时执行,也就只会有其中一条sql先执行成功,另外一条后执行,也如上文提及到的场景一样。

LUA脚本保持库存原子性

其实用方案四的时候,扣减redis的库存时,最好用lua脚本处理,因为如果剩余1个时,用户买100个,这个时候按照方案四,其实会先把key increase -100就会变负99。

所以用lua脚本先查询数量剩余多少,是否够减100后,再去减100。

替换“库存不足”那个判断到incre的那几行代码,没在这里详细描述。

简单说一下分布式事务:

分开两个系统处理库存和订单时,这个时候可以用LCN框架做分布式事务,但是因为是http请求的,也是有概率会订单系统的网络超时,导致未返回结果。

其实也可以使用最终一致性的方式,数据表记录一条交互流水记录,更新库存成功后,更新这个交互流水记录的库存操作字段为已处理,订单处理字段为处理中,然后发送mq,等待订单创建生成回调。也要做定时任务做主动查询订单系统的结果,以防没有结果回来。

方案优势

不需要频繁访问数据库商品库存还有多少

不阻塞其他用户

安全扣减库存量

内存访问库存数量,减少数据库交互

高并发额外优化

用户访问下单是,前端ui可以让用户触发结算后,把按钮置灰色,防止重复触发。

可以按照库存数量来选定是否要用redis,因为如果库存数量少,或者说最近下单次数少的商品,就不用放redis,因为少人看和买的情况下,不必放redis导致占用内存。

如果到时间点抢购时,可以使用mq队列形式,用户触发购买商品后,进入队列,让用户的页面一直在转圈圈,等轮到他买的时候再进入结算页面,结算页面的后续流程和本文一致。

欢迎关注

我的公众号 :地藏思维

掘金:地藏Kelvin

简书:地藏Kelvin

<think>我们正在讨论高并发场景防止库存的技术方案。根据引用内容,库存的主要原因包括:并发读取库存数据不一致、库存扣减操作非原子性、缺乏有效的并发控制机制。解决方案可以从数据库层、缓存层以及分布式锁等方面考虑。###1.数据库层解决方案####1.1乐观锁在数据库更新使用版本号(或间戳)实现乐观锁。在更新库存,检查版本号是否与读取一致,并确保库存充足:```sqlUPDATEinventorySETstock=stock-#{quantity},version=version+1WHEREproduct_id=#{productId}ANDversion=#{version}ANDstock>=#{quantity}```如果更新影响的行数为0,则表示库存不足或版本号已变更(有其他请求已修改),此应回滚事务或重试[^1]。####1.2悲观锁使用数据库的排他锁(如`SELECT...FORUPDATE`)在读取库存锁定记录,确保后续更新操作在锁保护下进行。但这种方式在高并发下可能导致性能瓶颈。###2.缓存层解决方案(如Redis)####2.1原子操作利用Redis的原子操作(如`DECRBY`、`INCRBY`)来扣减库存:```redisDECRBYkey_namequantity```如果返回值大于等于0,则表示扣减成功;否则需要回滚(通过`INCRBY`恢复)[^2]。####2.2Lua脚本将库存检查和扣减操作封装在Lua脚本中,保证原子性:```lualocalstock=tonumber(redis.call('GET',KEYS[1]))ifstock>=tonumber(ARGV[1])thenredis.call('DECRBY',KEYS[1],ARGV[1])return1--成功elsereturn0--失败end```####2.3分布式锁使用Redis的`SETNX`(或Redisson的分布式锁)控制同一间只有一个请求能执行库存扣减。但分布式锁在高并发下可能成为性能瓶颈。###3.库存分片对于大流量场景,可以将库存拆分为多个分片(如10个分片,每个分片持有部分库存)。用户请求随机路由到不同分片,少单个分片的并发压力[^3]。但需注意:-库存分布在多个分片,可能出现部分分片库存不足的情况,需设计补偿机制(如跨分片调拨)。-若用户一次购买多个商品,可能需要聚合多个分片的库存信息。###4.预扣库存订单创建前先预扣库存(如将库存状态标记为“预扣”),待支付成功后再实际扣减。若支付,则释放预扣库存。这可以避免支付过程中的库存占用问题。###5.消息队列削峰将库存扣减请求放入消息队列(如Kafka、RabbitMQ),由消费者按顺序处理。通过控制消费者数量实现并发控制,但会引入异步延迟。###总结-**低并发场景**:数据库乐观锁即可满足。-**高并发场景**:推荐使用Redis原子操作或Lua脚本,配合库存分片和消息队列削峰。-**极端高并发**:可结合分片、预扣库存、异步队列等多种方案。§§相关问题§§1.乐观锁在高并发场景下重试次数过多怎么办?2.如何设计库存分片策略以少跨分片调拨?3.Redis实现库存扣减,如何保证缓存与数据库的数据一致性?4.预扣库存模式下,如何处理用户支付后的库存释放?</think>### 高并发场景防止库存的解决方案 库存高并发场景中的常见问题,主要由**并发读取数据不一致**、**非原子性操作**和**缺乏并发控制**引起。以下是综合技术方案,结合数据库层、缓存层和架构优化: #### 一、数据库层解决方案 1. **乐观锁(版本号控制)** 在商品表中增加版本号字段,更新校验版本号: ```sql UPDATE inventory SET stock = stock - #{buy_quantity}, version = version + 1 WHERE product_id = #{product_id} AND version = #{old_version} -- 读取的版本号 AND stock >= #{buy_quantity} -- 防止负数库存 ``` - ✅ 优点:轻量级并发控制 - ❌ 缺点:高并发下失败率较高,需重试机制[^1] 2. **悲观锁(SELECT FOR UPDATE)** 事务中锁定记录: ```sql BEGIN; SELECT stock FROM inventory WHERE product_id = #{product_id} FOR UPDATE; -- 业务校验后更新库存 UPDATE inventory SET stock = stock - #{quantity} WHERE ...; COMMIT; ``` - ✅ 优点:保证强一致性 - ❌ 缺点:数据库性能瓶颈,死锁风险 #### 二、缓存层解决方案(Redis为核心) 1. **原子操作扣减库存** 使用Redis的原子命令: ```bash DECRBY stock_key {quantity} # 扣减库存 INCRBY stock_key {quantity} # 回滚库存 ``` - 执行后判断返回值:`>=0`表示成功,`<0`需回滚[^2] 2. **Lua脚本保证原子性** 将库存校验和扣减封装为原子操作: ```lua local stock = tonumber(redis.call('GET', KEYS[1])) if stock >= tonumber(ARGV[1]) then redis.call('DECRBY', KEYS[1], ARGV[1]) return 1 -- 成功 end return 0 -- 失败 ``` 3. **分布式锁控制** 使用Redisson实现分布式锁: ```java RLock lock = redisson.getLock("stock_lock"); lock.lock(); try { // 执行库存操作 } finally { lock.unlock(); } ``` #### 三、架构层优化 1. **库存分片** - 将总库存拆分为多个子库存(如`stock_1`、`stock_2`) - 请求通过哈希路由到不同分片,降低单点压力 - ⚠️ 注意:需处理跨分片库存调拨问题[^3] 2. **异步队列削峰** ```mermaid graph LR 用户请求-->消息队列(Kafka/RabbitMQ) 消息队列-->消费者组[库存服务集群] 消费者组-->数据库 ``` - 请求先入队列,消费者按可控速度处理 3. **预扣库存机制** - 步骤1:用户下单预占库存(状态为"锁定") - 步骤2:支付成功后实际扣减 - 步骤3:未支付自动释放库存 #### 四、方案选型建议 | 场景 | 推荐方案 | 适用并发量 | |------------|------------------------------|------------| | 低频抢购 | 数据库乐观锁 | < 1000 QPS | | 秒杀场景 | Redis原子操作 + Lua脚本 | 1万~10万 QPS | | 极端高并发 | 库存分片 + 异步队列 | > 10万 QPS | > **关键注意事项**: > 1. Redis与数据库需通过**双写机制**或**定同步**保证数据一致性 > 2. 必须实现**库存回滚逻辑**(如订单取消) > 3. 前端添加**限流策略**(如令牌桶算法) ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值