Golang实现Redis分布式锁解决秒杀问题

已于 2023-08-10 09:21:45 修改
阅读量930 收藏 1
点赞数
分类专栏： 考试系统 Redis 文章标签： golang redis
于 2023-08-07 10:37:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunriseYJP/article/details/132136325
版权

先写一个脚本sql，插入2000个用户

INSERT INTO sys_users (mobile, password)
SELECT 
    numbers.n AS mobile,
    '$2a$10$zKQfSn/GCcR6MX4nHk3MsOMhJnI0qxN4MFdiufDMH2wzuTaR9G1sq' AS password
FROM 
    (
        SELECT ones.n + tens.n*10 + hundreds.n*100 + thousands.n*1000 + 1 AS n
        FROM 
            (SELECT 0 AS n UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5 UNION ALL SELECT 6 UNION ALL SELECT 7 UNION ALL SELECT 8 UNION ALL SELECT 9) ones
            CROSS JOIN (SELECT 0 AS n UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5 UNION ALL SELECT 6 UNION ALL SELECT 7 UNION ALL SELECT 8 UNION ALL SELECT 9) tens
            CROSS JOIN (SELECT 0 AS n UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5 UNION ALL SELECT 6 UNION ALL SELECT 7 UNION ALL SELECT 8 UNION ALL SELECT 9) hundreds
            CROSS JOIN (SELECT 0 AS n UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5 UNION ALL SELECT 6 UNION ALL SELECT 7 UNION ALL SELECT 8 UNION ALL SELECT 9) thousands
        ORDER BY n
    ) numbers
LIMIT 2000;

登录是通过2个字段，一个是mobile，一个是password，生成了mobile从1到2000，密码默认是123456

然后写一个单元测试，实现新注册的2000个用户登录，然后获取token

package system

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"reflect"
	"runtime"
	"strings"
	"sync"
	"testing"
	"time"
)

var Global_client *http.Client

func GetGlobalClient() {
	client := &http.Client{
		Transport: &http.Transport{
			MaxIdleConns: 20, // 设置连接池大小为 200
		},
	}
	Global_client = client
}
func TestBaseApi_TokenNext(t *testing.T) {
	var wg sync.WaitGroup
	loginNum := 2000
	GetGlobalClient()
	s := make(chan string, loginNum)
	limit := make(chan int, 20000)
	//go prilimit(limit)
	go Show()
	for i := 1; i <= 2000000; i++ {
		mobile := fmt.Sprintf("%d", i)
		wg.Add(1)
		password := "123456"
		//向通道中发送值，如果满了500个，则会阻塞
		limit <- 1111
		go obtainToken(mobile, password, &wg, limit, s)
	}
	wg.Wait()

	//当数据都到了通道里面之后，我们可以关闭通道
	close(s)
	fmt.Println("通道的长度为：",len(s))
	file, err := os.OpenFile("E:\\Go\\goproject\\LearnExam\\sever\\token.txt", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
	defer file.Close()
	for token := range s {
		if token == "" {
			continue
		}
		_, err = file.WriteString(token + "\n")
		if err != nil {
			return
		}
	}

}

func Show() {
	for {
		num := runtime.NumGoroutine()
		fmt.Printf("当前程序中的协程数量：%d\n", num)
		time.Sleep(1 * time.Second)
	}
}

func AppendStringToFile(filePath string, content string) error {
	file, err := os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
	if err != nil {
		return err
	}
	defer file.Close()
	_, err = file.WriteString(content + "\n")
	if err != nil {
		return err
	}

	return nil
}
func obtainToken(mobile, password string, wg *sync.WaitGroup, limit chan int, s chan string) {
	defer wg.Done()

	type Body struct {
		Mobile   string `json:"mobile"`
		Password string `json:"password"`
	}
	b := Body{
		mobile, password,
	}

	bodymarshal, err := json.Marshal(&b)
	if err != nil {
		return
	}
	//再处理一下
	reqBody := strings.NewReader(string(bodymarshal))
	req, err := http.NewRequest("POST", "." +
		"", reqBody)
	if err != nil {
		fmt.Printf("Error creating request for user %s: %v\n", mobile, err)
		return
	}
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	resp, err := Global_client.Do(req)
	if err != nil {
		//fmt.Printf("Error sending request for user %s: %v\n", mobile, err)
		fmt.Printf("Error sending request for user %s: %+v\n", mobile, err)
		fmt.Println("反射：", reflect.TypeOf(err))
		fmt.Println("err是EOF,那resp是:",resp)
		return
	}
	//defer func(Body io.ReadCloser) {
	//	err = Body.Close()
	//	if err != nil {
	//
	//	}
	//}(resp.Body)
	body, err := ioutil.ReadAll(resp.Body) //把请求到的body转化成byte[]
	if err != nil {
		return
	}
	type Result struct {
		Code int `json:"code"`
		Data struct {
			Token string `json:"token"`
		} `json:"data"`
	}
	r := Result{}
	err = json.Unmarshal(body, &r)
	if err != nil {
		return
	}
	if r.Code == 0 {
		s <- r.Data.Token
		temp := <-limit
		fmt.Println("通道取值：", temp)
		fmt.Printf("Token obtained for user %s\n", mobile)
	} else {
		fmt.Printf("Failed to obtain token for user %s\n", mobile)
	}

}

我们使用有缓冲的通道和sync.WaitGroup信号量，来控制协程的数量，经过测试，发现limit，loginNum，影响到最后成功的结果，这其中的的原理我还暂时没有想清楚。limit为50，loginNum为2000，会存在服务端正常返回，但是客户端报EOF，limit为50，loginNum为500的时候，不会出现EOF问题，那说明limit为50是没问题的，按照道理说，及时loginNum增大到100000也不会有问题，但是却出现了问题，后面再解决吧。

现在已经拿到了2000个用户的token了，我们使用jemter工具来进行压测

MySQL层面解决

这个是要测试的函数

func (e *ExamService) PayExam(c *gin.Context, p request.PayExam) (err error) {
	//基本参数校验
	if p.ExamId == 0 {
		return errors.New("参数有误")
	}
	//获取用户登录信息
	userID := utils.GetUserID(c)
	fmt.Println("userid:", userID)
	//判断用户是否已经买过
	var orders []examination.Order
	cond := fmt.Sprintf("order_type_id = 1 and commodity_id = %v",p.ExamId)
	err = global.GVA_DB.Model(&system.SysUser{GVA_MODEL: global.GVA_MODEL{ID: userID}}).Association("Orders").Find(&orders,cond)
	if err != nil {
		return err
	}
	if len(orders) > 0 {
		return errors.New("您已经购买过了，无需再次购买")
	}
	//exam, err := (&ExamService{}).GetExam(request.GetExam{ExamId: p.ExamId})
	exam := examination.Exam{
		GVA_MODEL: global.GVA_MODEL{ID: p.ExamId},
	}
	err = global.GVA_DB.Select("Stock", "ExamName").First(&exam).Error
	fmt.Println("库存：",exam.Stock)
	if err == gorm.ErrRecordNotFound {
		return errors.New("该场考试不存在")
	}

	if exam.Stock <= 0 {
		return errors.New("该场考试已经售卖完了")
	}
	//扣考试的库存
	//err = global.GVA_DB.Model(&exam).Update("stock", exam.Stock-1).Error
	sql := fmt.Sprintf("update exams set stock = stock - 1 WHERE id = %d",p.ExamId)
	err = global.GVA_DB.Debug().Raw(sql).Scan(nil).Error

	if err != nil {
		return errors.New("扣除库存失败")
	}
	//下单
	err = global.GVA_DB.Create(&examination.Order{Name: "购买考试：" + exam.ExamName, OrderTypeID: 1, OrderTypeDetail: "考试",SysUserID: userID,CommodityID: p.ExamId}).Error
	return err
}

其中，由于exams表中的stock是uint类型，在用gorm建表的时候，自动设置了BIGINT UNSIGNED，已经在MySQL层面就解决了这个秒杀问题，我们接下来把stock改成int类型，然后使用redis的分布式锁来解决这个问题


Redis层面解决

我们还是使用MySQL用来记录下单记录，但是库存信息缓存到了redis里面

最关键的是

result, err := global.GVA_REDIS.HIncrBy(context.Background(), key, "stock", -1).Result()

 不是原子性的，我们使用lua脚本让其原子性，然后就可以解决这个问题了（ MySQL的一条update就是一个事务，是具有原子性的）

func (e *ExamService) PayExamByRedis(c *gin.Context, p request.PayExam) (err error) {
	//基本参数校验
	if p.ExamId == 0 {
		return errors.New("参数有误")
	}
	//获取用户登录信息
	userID := utils.GetUserID(c)
	fmt.Println("userid:", userID)
	key := utils.ExamPrefix + strconv.Itoa(int(p.ExamId))
	//判断用户是否已经买过
	var orders []examination.Order
	cond := fmt.Sprintf("order_type_id = 1 and commodity_id = %v", p.ExamId)
	err = global.GVA_DB.Model(&system.SysUser{GVA_MODEL: global.GVA_MODEL{ID: userID}}).Association("Orders").Find(&orders, cond)
	if err != nil {
		return err
	}
	if len(orders) > 0 {
		return errors.New("您已经购买过了，无需再次购买")
	}
	stock, err := global.GVA_REDIS.HGet(context.Background(), key, "stock").Result()
	name, err := global.GVA_REDIS.HGet(context.Background(), key, "exam_name").Result()
	fmt.Println("库存：", stock)
	if err == redis.Nil {
		return errors.New("该场考试不存在")
	}
	stockInt, err := strconv.Atoi(stock)
	if stockInt <= 0 {
		return errors.New("该场考试已经售卖完了")
	}
	//这个操作不是原子性的
	//result, err := global.GVA_REDIS.HIncrBy(context.Background(), key, "stock", -1).Result()
	//使用Lua脚本让其原子化
	script := fmt.Sprintf(`if (redis.call('hexists', KEYS[1], KEYS[2]) == 1) then	local stock = tonumber(redis.call('hget', KEYS[1], KEYS[2]));
	if (stock > 0) then
	   redis.call('hincrby', KEYS[1], KEYS[2], -1);
	   return stock;
	end;
    return 0;
end;`)
	result, err := global.GVA_REDIS.Eval(context.Background(), script, []string{key, "stock"}, -1).Int()
	if err != nil {
		fmt.Println(err)
		return errors.New(err.Error())
	}
	if result == 0 {
		return errors.New("该场考试已经售卖完了")
	}
	//扣考试的库存
	//下单
	err = global.GVA_DB.Create(&examination.Order{Name: "购买考试：" + name, OrderTypeID: 1, OrderTypeDetail: "考试", SysUserID: userID, CommodityID: p.ExamId}).Error
	if err != nil {
		global.GVA_LOG.Error("mysql插入购买考试记录失败", zap.Error(err))
		return err
	}
	return err
}

Channel层面解决

func (e *ExamApi) PayExam(c *gin.Context) {
	global.LimitPayExamChannel <- 1
	var p request.PayExam
	err := c.ShouldBindJSON(&p)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	//err = examService.PayExamByRedis(c, p)
	err = examService.PayExamByChannel(c, p)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		<-global.LimitPayExamChannel
		return
	}
	userID := utils.GetUserID(c)
	response.OkWithMessage(strconv.Itoa(int(userID))+"购买成功", c)
	<-global.LimitPayExamChannel
}

我们在全局初始化一个缓冲区容量为1的通道，虽然秒杀期间并发了很多的请求，但是我一次只处理一个，这样能保证结果是正确的，不会出现超卖问题，但是失去了并发的意义。

大杯无糖
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用redis实现golang的分布式锁
qq_27176027的博客
08-10 1437
利用redis，实现redis锁
基于go和redis实现分布式锁
10-14
本文将深入探讨如何使用Go语言（Golang）和Redis来实现分布式锁，并介绍其中涉及到的关键概念和实现方式，包括看门狗（Watchdog）和红锁（RedLock）策略。 **一、Redis作为分布式锁** Redis因其高性能、轻量级以及...
Golang实现Redis分布式锁（Lua脚本+可重入+自动续期）
weixin_45565886的博客
03-16 1602
Golang实现Redis分布式锁（Lua脚本+可重入+自动续期）
使用Go+Lua解决Redis秒杀中库存与超卖问题
weixin_43495948的博客
11-22 1797
Lua操作redis能够比较好的解决这个问题。因为redis中使用watch是使用了悲观锁的形态，而悲观锁会自然得造成库存问题，因此要使用乐观锁。而redis天然不支持乐观锁，基于此，需要时lua来编写相关脚本。使用watch进行监视key，关键部分如下。但是这样会造成一个问题，就是抢购不完，会有一些库存，但是又有人没有抢到。面对并发的情况下会出现超卖的情况，redis数据库中会出现负值的情况。即使你在操作之前进行了数据的判断。
最新用 Go + Redis 实现分布式锁，2024年最新Golang内存优化面试
2401_84925044的博客
05-13 964
设置成功会自动返回“OK”，设置失败返回“NULL Bulk Reply”(img-AZjWkYGv-1715577991107)]– 锁key.value不等于传入的value则说明是第一次获取锁。// 见core/stringx/random.go：Randn。// 实际上go-zero提供更加高效的随机字符串生成方式。// 默认锁过期时间为500ms，防止死锁。// 获取锁时，锁的值通过随机字符串生成。// 锁value，防止锁被别人获取到。// 默认超时时间，防止死锁。// redis客户端。
golang实现的电商秒杀项目
wm1634208243的博客
08-13 97
这个系统的主要目的在于秒杀，所有其他地方都做的很简单。，非常适合想学习golang后端的同学，当作实习项目也不错。完整资料进入【数字空间】查看——搜索"writebug"消息队列：RabbitMQ。限流器：tollbooth。分布式方案：hash环。
Go语言实现Redis分布式锁
m0_57408211的博客
04-04 1255
本文将基于go语言，使用了一个常用的go Redis客户端一步一步探索与实现一个简单的Redis分布式锁。SETNX 命令用于在Redis中设置某个不存在的键的值。如果该键不存在，则设置成功，如果该键存在，则设置失败，不作任何动作。基于此可以实现一种简单的抢占机制。先连接redis。新建lock.go文件。创建lock结构体，加锁和解锁方法。
Go语言实现Redis分布式锁2
m0_57408211的博客
04-08 863
注意，这里也是使用Lua脚本封装了确认锁与锁续期的操作来用于原子化，以防止误续期了其他持有者的锁。这里仍然存在一个问题：当锁的持有者任务未完成，但是锁的有效期已过，虽然持有者此时仍可以完成任务，并且也不会误删其他持有者的锁，但是此时可能会存在多个执行者同时执行临界区代码，使得数据的一致性难以保证，造成意外的后果，分布式锁就失去了意义。因此，需要一个锁的自动续期机制，分布式锁框架Redission中就有这么一个看门狗，专门为将要到期的锁进行续期。之前的是只尝试获取一次锁，要是获取失败就不再尝试了。
golang实现Redis分布式自旋锁+本地自旋锁
01-20
golang使用redis的setnx实现了一个自选锁，有key超时，同时也有我们调用redis链接时的超时。 package locker import ( context github.com/go-redis/redis runtime time ) type Lock struct { resource string...
基于go语言的redis分布式锁实现.zip
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： ...
基于Go语言实现的高性能Redis分布式锁服务。.zip
最新发布
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： ...
go语言秒杀项目和ppt文档
07-31
GO 主要现在做微服务。分布式 高并发，GO的标准库就很强大了。web框架可以考虑GIN。
golang秒杀系统和web后台开发视频
04-21
go秒杀系统和web后台系统开发视频，值得学习，值得学习，go很好的视频。
redislock:使用Redis简化分布式锁实现
07-24
使用简化分布式锁定实现。 有关更多信息，请参阅示例。 例子 import ( "fmt" "time" "github.com/bsm/redislock" "github.com/go-redis/redis/v8" ) func main () { // Connect to redis. client := redis ....
golang实现Redis分布式锁
地球流浪猫的博客
03-11 90
golang实现Redis分布式锁
php $lang,PHP+Golang 商品秒杀功能
weixin_34511754的博客
03-12 117
框架:laravel秒杀组成部分：商品、秒杀场次、Redis、模拟秒杀秒杀过程：一、实现商品、秒杀场次、秒杀场次和商品关联的CRUD；二、定时将秒杀场次、商品、库存等信息提前写入redis；三、配置Redis持久化；四、实现秒杀下单逻辑；五、定时删除秒杀的过期信息并释放库存；六、使用golang并发编程模拟秒杀。PS:整个流程中，涉及异步并发的地方：定时存储数据到redis、秒杀生成订单、查询当前...
Golang基于Redis实现分布式读写锁
fwhezfwhez的博客
03-07 1175
package redistool import ( "github.com/fwhezfwhez/errorx" "github.com/garyburd/redigo/redis" "time" ) type RedisRWMutex struct { key string maxlocksecond int // 锁定状态标记的最大时间 maxretryTimes int // 最大阻塞重试次数 retryInteval
golang-redis锁
qq_41864345的博客
04-22 261
package main import ( "crypto/tls" "fmt" "github.com/go-redis/redis" "github.com/go-redsync/redsync" redis2 "github.com/gomodule/redigo/redis" "net" "time" ) func main() { InitRedis() mutex := SyncLook.NewMutex("bug_eater", redsync.SetExpiry(tim
go 商品秒杀系统架构设计
一越王超的博客
04-26 860
秒杀抢购的发展经历如下： 1.0版，没有独立的秒杀系统，代码高度耦合，由于MySQL的性能瓶颈大流量涌入会导致平台整体崩溃。 2.0版，使用Redis搭建独立的秒杀系统，实现系统解耦进行限流和过载保护，平台不会崩溃，但是秒杀系统可能会崩溃。 3.0版，对秒杀系统内部进行拆分，对秒杀系统单独做限流和过载保护等。
golang 实现redis分布式锁
05-02
实现 Redis 分布式锁的基本思路是利用 Redis 的 SETNX 命令（SET if Not eXists）实现。SETNX 命令会在 key 不存在的情况下，将 key 的值设为 value，如果 key 已经存在，则不做任何操作。 以下是一个简单的 Golang 实现 Redis 分布式锁的代码示例： ```go package redislock import ( "fmt" "time" "github.com/go-redis/redis/v7" ) type RedisLock struct { redisClient *redis.Client key string value string expiration time.Duration } func NewRedisLock(redisClient *redis.Client, key, value string, expiration time.Duration) *RedisLock { return &RedisLock{ redisClient: redisClient, key: key, value: value, expiration: expiration, } } func (r *RedisLock) Lock() (bool, error) { success, err := r.redisClient.SetNX(r.key, r.value, r.expiration).Result() if err != nil { return false, err } return success, nil } func (r *RedisLock) Unlock() error { err := r.redisClient.Del(r.key).Err() if err != nil { return err } return nil } ``` 在上面的代码中，NewRedisLock 函数用于创建一个 RedisLock 实例，需要传入 Redis 客户端、锁的 key、锁的值、锁的过期时间。Lock 方法用于尝试获取锁，如果获取成功，返回 true，否则返回 false。Unlock 方法用于释放锁。 以下是一个简单的使用示例： ```go package main import ( "fmt" "time" "github.com/go-redis/redis/v7" "github.com/yourusername/redislock" ) func main() { redisClient := redis.NewClient(&redis.Options{ Addr: "localhost:6379", DB: 0, }) lock := redislock.NewRedisLock(redisClient, "my-lock", "my-value", 10*time.Second) success, err := lock.Lock() if err != nil { fmt.Println("failed to acquire lock:", err) return } if !success { fmt.Println("lock is already held by another process") return } defer lock.Unlock() // Do some work } ``` 在上面的示例中，我们创建了一个 Redis 客户端，并且创建了一个 RedisLock 实例。然后，我们调用 Lock 方法尝试获取锁，如果获取成功，就可以进行一些需要加锁的操作。最后，我们调用 Unlock 方法释放锁。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值