超卖问题 学习记录 go实现

原创 已于 2024-11-08 09:49:46 修改 · 439 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#学习
于 2024-11-07 22:20:11 首次发布

对于高并发环境下，超卖问题一直是非常常见的问题，对于有限的库存和突发的高请求下，避免产生超卖是重中之重。 主要是一直看面试题，结果面试当场，脑袋忘记了，于是亲自动手简单做一遍，避免下次发生。以下解决方案暂时没有MQ参与的解决

方法1：使用MySQL悲观锁，实现约束，update操作，在MySQL默认事务隔离下，是会加上X锁进行写限制的。

func UpdateGoodsWithTrans(goodsId string, numToPurchase int64) (int64, error) {
	tx, err := globalDb.db.Begin()
	if err != nil {
		return 0, fmt.Errorf("failed to begin transaction: %v", err)
	}
	defer tx.Rollback()

	result, err := tx.Exec("UPDATE goods SET goods_remains = goods_remains - ? WHERE goods_id = ? and goods_remains >= ?", numToPurchase, goodsId, numToPurchase)
	if err != nil {
		return 0, fmt.Errorf("failed to update goods: %v", err)
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return 0, fmt.Errorf("failed to get rows affected: %v", err)
	}

	if rowsAffected == 0 {
		return 0, fmt.Errorf("no goods found with goods_id: %s", goodsId)
	}

	if err := tx.Commit(); err != nil {
		return 0, fmt.Errorf("failed to commit transaction: %v", err)
	}

	return numToPurchase, nil
}

方法2：MySQL的乐观锁实现，常见的有依靠版本号或时间戳

func UpdateGoodsWithVersion(goodsId string, numToPurchase int64) (int64, error) {
	tx, err := globalDb.db.Begin()
	goodsRemains, version, err := GetGoods(goodsId)
	if err != nil {
		return 0, fmt.Errorf("failed to begin transaction: %v", err)
	}
	defer tx.Rollback()

	if goodsRemains < numToPurchase {
		return 0, fmt.Errorf("failed to update goods: %v", err)
	}

	result, err := tx.Exec("UPDATE goods SET goods_remains = goods_remains - ?, version = version + 1 WHERE goods_id = ? and version = ?", numToPurchase, goodsId, version)
	if err != nil {
		return 0, fmt.Errorf("failed to update goods: %v", err)
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return 0, fmt.Errorf("failed to get rows affected: %v", err)
	}

	if rowsAffected == 0 {
		return 0, fmt.Errorf("no goods found with goods_id: %s", goodsId)
	}

	if err := tx.Commit(); err != nil {
		return 0, fmt.Errorf("failed to commit transaction: %v", err)
	}

	return numToPurchase, nil
}

方法3：使用lua脚本， 在redis中实现原子操作。redis中也支持简单事务，但是看网上说不推荐使用。

#public包下
const LuaUpdateRemains = `
local currentRemains = redis.call("GET", KEYS[1])
if currentRemains == false then
    return 0
end
if tonumber(currentRemains) + tonumber(ARGV[1]) < 0 then
    return -1
end
return redis.call("INCRBY", KEYS[1], ARGV[1])
`

#redis包下
func UpdateProductRemains(productId string, num int) error {
	key := public.Product_key + productId

	result, err := rdb.Eval(context.Background(), public.LuaUpdateRemains, []string{key}, num).Result()
	if err != nil {
		return fmt.Errorf("更新商品库存失败: %v", err)
	}

	if result == int64(-1) {
		return fmt.Errorf("商品库存不足，无法减少库存")
	}

	return nil
}

整体代码依照包区分开来

data_base包

package data_base

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"log"
	"time"
)

type DB struct {
	db *sql.DB
}

var globalDb *DB

func init() {
	dsn := "root:000529@tcp(localhost:3306)/over_buy?charset=utf8mb4&parseTime=True&loc=Local"

	db, err := sql.Open("mysql", dsn)
	if err != nil {
		log.Fatal("连接数据库失败: ", err)
	}
	//defer db.Close()

	db.SetMaxOpenConns(10)
	db.SetMaxIdleConns(5)
	db.SetConnMaxLifetime(30 * time.Minute)

	// 测试连接是否成功
	err = db.Ping()
	if err != nil {
		log.Fatal("数据库连接失败: ", err)
	} else {
		fmt.Println("数据库连接池创建成功!")
	}
	globalDb = &DB{
		db: db,
	}
}

func CloseDB() {
	globalDb.db.Close()
}

func GetGoods(goodsId string) (int64, int64, error) {
	goodsRemains := int64(0)
	version := int64(0)
	err := globalDb.db.QueryRow("SELECT goods_id, goods_remains, version FROM goods WHERE goods_id = ?",
		goodsId).Scan(&goodsId, &goodsRemains, &version)
	return goodsRemains, version, err
}

func UpdateGoods(goodsId string, goodsRemains int64) (int64, error) {
	result, err := globalDb.db.Exec("UPDATE goods SET goods_remains = ?, version = version + 1 WHERE goods_id = ?", goodsRemains, goodsId)
	if err != nil {
		return 0, err
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return 0, err
	}

	if rowsAffected == 0 {
		return 0, fmt.Errorf("no goods found with goods_id: %s", goodsId)
	}
	return goodsRemains, nil
}

// 悲观锁
func UpdateGoodsWithTrans(goodsId string, numToPurchase int64) (int64, error) {
	tx, err := globalDb.db.Begin()
	if err != nil {
		return 0, fmt.Errorf("failed to begin transaction: %v", err)
	}
	defer tx.Rollback()

	result, err := tx.Exec("UPDATE goods SET goods_remains = goods_remains - ? WHERE goods_id = ? and goods_remains >= ?", numToPurchase, goodsId, numToPurchase)
	if err != nil {
		return 0, fmt.Errorf("failed to update goods: %v", err)
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return 0, fmt.Errorf("failed to get rows affected: %v", err)
	}

	if rowsAffected == 0 {
		return 0, fmt.Errorf("no goods found with goods_id: %s", goodsId)
	}

	if err := tx.Commit(); err != nil {
		return 0, fmt.Errorf("failed to commit transaction: %v", err)
	}

	return numToPurchase, nil
}

// 乐观锁形式实现
func UpdateGoodsWithVersion(goodsId string, numToPurchase int64) (int64, error) {
	tx, err := globalDb.db.Begin()
	goodsRemains, version, err := GetGoods(goodsId)
	if err != nil {
		return 0, fmt.Errorf("failed to begin transaction: %v", err)
	}
	defer tx.Rollback()

	if goodsRemains < numToPurchase {
		return 0, fmt.Errorf("failed to update goods: %v", err)
	}

	result, err := tx.Exec("UPDATE goods SET goods_remains = goods_remains - ?, version = version + 1 WHERE goods_id = ? and version = ?", numToPurchase, goodsId, version)
	if err != nil {
		return 0, fmt.Errorf("failed to update goods: %v", err)
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return 0, fmt.Errorf("failed to get rows affected: %v", err)
	}

	if rowsAffected == 0 {
		return 0, fmt.Errorf("no goods found with goods_id: %s", goodsId)
	}

	if err := tx.Commit(); err != nil {
		return 0, fmt.Errorf("failed to commit transaction: %v", err)
	}

	return numToPurchase, nil
}

package data_base

import (
	"context"
	"fmt"
	redis "github.com/go-redis/redis/v8"
	"log"
	"over_buy/public"
)

var (
	rdb *redis.Client // Redis 客户端实例
	ctx = context.Background()
)

// 初始化 Redis 连接池
func init() {
	rdb = redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // Redis 服务器地址
		Password: "",               // 密码为空
		DB:       0,                // 默认数据库
	})

	// 测试连接是否成功
	_, err := rdb.Ping(ctx).Result()
	if err != nil {
		log.Fatalf("无法连接到 Redis: %v", err)
	}
	fmt.Println("成功连接到 Redis")
}

func RestoreProductInfo(productId string, remains int64) error {
	key := public.Product_key + productId
	// 使用 SET 命令设置库存
	err := rdb.Set(ctx, key, remains, 0).Err()
	if err != nil {
		return fmt.Errorf("设置商品库存失败: %v", err)
	}
	return nil
}

func UpdateProductRemains(productId string, num int) error {
	key := public.Product_key + productId

	result, err := rdb.Eval(context.Background(), public.LuaUpdateRemains, []string{key}, num).Result()
	if err != nil {
		return fmt.Errorf("更新商品库存失败: %v", err)
	}

	if result == int64(-1) {
		return fmt.Errorf("商品库存不足，无法减少库存")
	}

	return nil
}

public包

package public

const (
	Product_key = "product"
)

// Lua 脚本：获取库存，检查库存是否足够，若足够则更新库存
const LuaUpdateRemains = `
local currentRemains = redis.call("GET", KEYS[1])
if currentRemains == false then
    return 0
end
if tonumber(currentRemains) + tonumber(ARGV[1]) < 0 then
    return -1
end
return redis.call("INCRBY", KEYS[1], ARGV[1])
`

main

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"log"
	"over_buy/data_base"
)

func buyProduct1(c *gin.Context) {
	num, err := data_base.UpdateGoodsWithTrans("1", 1)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("success decrease : %d", num)
	}

}

func buyProduct2(c *gin.Context) {
	num, err := data_base.UpdateGoodsWithVersion("1", 1)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("success decrease : %d", num)
	}
}

func buyProduct3(c *gin.Context) {
	err := data_base.UpdateProductRemains("1", -1)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("success decrease")
		num, _, _ := data_base.GetGoods("1")
		data_base.UpdateGoods("1", num-1)
	}
}

func main() {
	defer data_base.CloseDB()
	r := gin.Default()
	goodsRemains, _, err := data_base.GetGoods("1")
	if err != nil {
		fmt.Println("获取库存失败:%v", err)
	}
	data_base.RestoreProductInfo("1", goodsRemains)

	// API 路由
	r.POST("/buy_with_lock1", buyProduct1)
	r.POST("/buy_with_lock2", buyProduct2)
	r.POST("/buy_with_lock3", buyProduct3)

	// 启动服务器
	if err = r.Run(":8080"); err != nil {
		log.Fatal("Unable to start server: ", err)
	}
}

结果详情

使用JMeter进行测试，开启十个线程十次循环，同时数据库最终结果为0，成功防止了货存降为负数。

golang测试库存超卖的探讨
hjc_042043的博客
08-03 301
库存超卖是电商中一个比较热门的话题，通过网上的搜索资料，控制库存有好几种，有分布式锁，有乐观锁等。其中有的是采用redis的watch事务来模拟乐观锁来处理超卖。今天拿它来和redis+lua的原子性做个对比。网上有的大神说用redis的watch机制可以模拟乐观锁，能保证其库存不超，我测试怎么不行呢，哪里错了，希望有兄弟能帮忙指出来。库存以10个为例，各跑20000次并发。抢购成功的记录也多了5条。库存量超了5个，如下图。
golang使用Redsync分布式锁
感谢您的访问，期待和大家一起在Go语言的世界中共同进步
05-27 944
分布式锁解释，分布式锁实现方式，golang使用分布式锁，mysql实现分布式锁，乐观锁，悲观锁
GORM使用笔记
qq_38374562的博客
12-09 2440
GORM使用笔记
golang学习之--利用channel实现火车站多窗口买票问题【解决超卖】
cyb_17302190874的博客
10-28 1019
eg：火车站有四个卖票窗口，一共有10000张票，现在设计一个方案实现自动售票，并且不发生超卖现象。 func main() { nums := 10000 //预置票量 incs := make(chan int, nums) for i:= nums ; i > 0; i-- {//利用channel保证原子性库存操作 incs <- i } for j:= 1; j <=4; j++ {//开启四个协程 go func () { for {
利用go特性实现高并发接口
qq_36453564的博客
07-16 1797
一. 用go语言自带的锁。 下面代码为抢购Api。 //锁 var mu sync.Mutex //抢购Api func (this *RushController) Purchase() { //商品ID goods_id := int64(1) //加锁 mu.Lock() //结束时解锁 defer mu.Unlock() //orm o := orm.NewOrm() //读取商品信息 m := models.Goods{Id: goods_id} err := o.Read(
解决库存超卖问题
qq_29744347的博客
08-21 1256
在并发的情况下扣减库存会出现库存超卖的现象。这里使用golang进行讲解，数据库操作使用gorm + mysql。先运行下面的代码将测试表和数据创建好。//换成自己的数据库连接 dsn := "root:Xrx@1994113@tcp(127.0.0.1:3306)/proxy?
Golang的学习记录
2301_80829687的博客
05-30 1864
golang的学习分享，和一些基本工具的使用​go run/go build​：运行或编译主文件。 ​go get vs go install​： go get：管理依赖（修改go.mod），适用于添加项目依赖。 go install：安装可执行文件到$GOPATH/bin，不修改go.mod。 ​gofmt​：代码格式化工具，支持简化代码（-s）、正则替换（-r）、写入文件（-w）等功能。 ​goimports​：自动处理导入依赖，弥补gofmt不足，安装方式与用法类似gofmt。
超卖优化：基于历史水位预测的K8s多卡GPU动态超卖调度实现
最新发布
m0_50889382的博客
06-24 186
通过历史水位预测实现 GPU 动态超卖，能打破传统 Kubernetes 静态调度的限制。在保障高优先级任务显存安全的前提下，这种收敛算法能有效提升物理卡利用率，提高集群整体吞吐能力。超卖本身带来一定风险，但通过多级指标监控与快速熔断降级策略，可将风险控制在可接受范围内。后续可结合机器学习对业务负载波峰波谷的预测，进一步提升超卖的安全性与精准度。所做更改总结：删除填充短语：移除“通常会遇到”、“往往会”等模糊表达，改为更直接的陈述打破公式结构。
项目中遇到的超卖问题及解决办法（使用go做测试工具）
aob30631的博客
12-25 427
　　超卖问题：在一个很短的时间内，Mysql的数据状态在 取出，比较，提交，或修改中，另外一个进程访问数据导致的超卖问题。 　　案例： 　　　　1.前端没有做限制，如果用户连续点击签到，那么会有多条数据发送到后端，如果数据状态没有来得及完全修改过来，导致用户的签到数据被多次添加。 　　　　2.每天签到用户的前3名用户可以获得一张价值100元的优惠券，如果有多名用户在很短的时间内同时...
koa超卖解决之分布式锁
m0_49867458的博客
03-16 3102
这里写自定义目录标题 解决超卖问题：（） apache benchmark：模拟并发请求 Redis：存储库存，用Redis 列表的长度来记录生成了多少订单 压力测试： ab -c 10 -n 1000 http://localhost:4000/ > llen orders 要处理这个问题有三种方法： 1判断 incrby 命令的返回值 可以直接判断返回值是否大于 0 来判断是否抢购成功，不再需要 get 命令 实现代码：先判断如果redis.incrby由商品id加-1到商品上，即减少一个商品，随
字节golang后端二面
weixin_54385104的博客
06-01 1377
是一个强大的工具，适用于需要线程隔离的数据存储场景。合理使用可以提高性能和简化代码，但也需要注意内存管理和线程安全问题。
【Golang】Go语言中如何通过Goroutine快速实现高并发
热门推荐
景天科技苑
10-10 5万+
并发编程是指在一个程序中同时运行多个任务，这些任务可以独立地执行，也可以相互协作。并发编程可以提高程序的执行效率，特别是在处理大量I/O操作或计算密集型任务时。 在Go语言中，并发编程主要通过goroutine和channel来实现。 Goroutine是Go语言独有的并发执行单元，它允许函数或方法并发执行，而无需手动管理线程。 Channel是Go语言中进行goroutine间通信和同步的主要机制。
基于SpringBoot+RabbitMQ+Redis开发的秒杀系统，实现异步下单、热点数据缓存、解决超卖等问题
笃行
06-04 4247
秒杀项目：SeckillProject 一、项目简介：  ​ ​ ​ ​SeckillProject基于Springboot开发的秒杀系统，实现的功能主要是登录、商品列表、商品详情、秒杀商品，订单详情等功能。在系统业务处理中，使用到分布式session维持会话、Redis预减库存降低数据库访问压力，消息队列异步下单（削峰）、客户端轮询结果、接口限流防刷等。 项目地址： https://github.com/pure-xiaojie/SeckillProject（希望
并发防超卖最简单的办法
北漂猿
12-19 744
测试代码： class Test { public function test(){ // 启动事务 Db::startTrans(); try { $prizeM = MarketingCampaignPrize::where('total','>',0)->where('campaign_id',80) ->g
库存防超卖（Redis Lua+分布式锁对比实践）
王中阳讲编程
11-19 861
在电商系统中，库存管理是一个至关重要的环节，特别是在高并发场景下（如秒杀、限时抢购等），如何保证库存的准确性，避免超卖现象，是系统稳定性和用户体验的关键。本文档详细介绍库存超卖问题，分析现有的解决方案，并通过实践对比Redis Lua脚本和分布式锁两种方案在库存扣减场景下的优缺点，提供完整的实现代码和最佳实践建议。库存超卖是指系统在高并发情况下，实际销售的商品数量超过了系统中记录的库存数量。在我们的电商系统中，传统的库存扣减实现虽然使用了数据库事务来保证原子性，但在高并发场景下，仍然可能出现超卖问题。
Golang的学习记录（一）补
2301_80829687的博客
05-31 960
Go模块管理三剑客分工明确： 1. go mod是项目经理 - init初始化项目 - tidy整理依赖关系 - vendor生成离线包 管理版本和依赖，确保工程规范 2. go get是采购员 - 负责下载第三方库 - 自动更新go.mod清单 - 遇到main包会顺手安装 但容易弄乱项目依赖 3. go install是安装工 - 专注安装可执行工具 - 不污染项目依赖清单 - 必须指定@版本号 是安装工具的标准姿势 三者协作：mod管项目，get下源码，install装工具，共同构建Go的工程化
Golang学习总结
weixin_45541397的博客
08-28 2191
一、基本语法 Golang 设计理念：一种事情有且只有一种方法完成 软件包安装 直接官网下载好，配置安装下环境变量即可 /etc/profile # 在这个文件写入会对所有用户生效 ~/.profile # 在这个文件写入只会对当前用户生效 # 以上两个文件中任意选择一个 # 将 Go 的安装目录记录下，比如安装目录为 /home/CHAO/Document/go/bin export GOROOT=/usr/local/go #这个表示go
Golang go mod简介
专注数据库、大数据领域干货分享，用严谨的数据技术广交天下朋友。
09-13 2862
什么是go.mod Go...
Golang相关学习记录
仮想の世界
05-25 434
Golang相关学习记录 书签 Golang相关学习记录 书签 练习代码 https://gobyexample.com/ 电子书，过程很详细 https://books.studygolang.com/gopl-zh/ch1/ch1-03.html 第三方库整理 https://github.com/avelino/awesome-go 挺实用的教程 http...
Golang 必知必会Go Mod命令
猫轻王的博客
03-15 2万+
通过以上可以轻松了解在Golang中go mod的使用方式。Go mod提供了一系列操作modules的命令，所有的go命令中现在已经内置了对module的支持，而不仅仅是go mod命令。例如使用go get时，会经常自动在后台添加、移除、升级、降级依赖包版本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值