go实现分布式锁

最新推荐文章于 2024-04-08 09:01:43 发布
最新推荐文章于 2024-04-08 09:01:43 发布
阅读量1.6k 收藏 9
点赞数 4
分类专栏： Go学习 文章标签： golang 分布式 悲观锁 乐观锁 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43135259/article/details/125508990
版权

简介

本文代码地址

本文以扣减库存为例,分别实现进程锁;mysql的悲观锁;乐观锁以及redis的分布式锁

表

CREATE TABLE `stocks` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `goods` varchar(20) DEFAULT NULL COMMENT '商品id',
  `stocks` int(11) DEFAULT NULL COMMENT '库存',
  `version` int(11) DEFAULT NULL COMMENT '乐观锁',
  PRIMARY KEY (`id`),
  KEY `idx_stocks_goods` (`goods`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

在这里插入图片描述

无锁

service

package service

import (
	context "context"
	"go-locks/no-lock/db"
	"go-locks/no-lock/model"
	"go-locks/no-lock/proto"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/emptypb"
)

type Server struct{}

func (s Server) SellStock(ctx context.Context, request *proto.StockRequest) (*emptypb.Empty, error) {
	tx := db.DB.Begin()
	for _, info := range request.StockInfos {
		var stock model.Stock
		if result := tx.Where(&model.Stock{Goods: info.GoodsId}).First(&stock); result.RowsAffected == 0 {
			return nil, status.Error(codes.NotFound, "商品信息不存在")
		}
		if stock.Stocks < info.Num {
			// 库存不足 回滚事务
			tx.Rollback()
			return nil, status.Error(codes.ResourceExhausted, "库存不足")
		}
		stock.Stocks -= info.Num
		tx.Save(stock)
	}
	tx.Commit()
	return &emptypb.Empty{}, nil
}

client

package main

import (
	"context"
	"go-locks/no-lock/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"sync"
)

var client proto.StockClient

func main() {
	conn, err := grpc.Dial("127.0.0.1:8088", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		panic(err)
	}
	client = proto.NewStockClient(conn)
	var wg sync.WaitGroup
	wg.Add(20)
	for i := 0; i < 20; i++ {
		go TestSellStock(&wg)
	}
	wg.Wait()
}

func TestSellStock(wg *sync.WaitGroup) {
	defer wg.Done()
	_, err := client.SellStock(context.Background(), &proto.StockRequest{
		StockInfos: []*proto.StockInfo{
			{
				GoodsId: "123456",
				Num:     1,
			},
		},
	})
	if err != nil {
		panic(err)
	}
}

测试

在这里插入图片描述
开启20gorouinte去扣减123456的库存;正常情况下123456的库存应该剩余480件,但由于我们没有进行加锁,导致库存还剩485件.这种情况在真实场景下是绝对不能接受的

进程锁

service

package service

import (
	context "context"
	"go-locks/process-lock/db"
	"go-locks/process-lock/model"
	"go-locks/process-lock/proto"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/emptypb"
	"sync"
)

type Server struct{}

var mutex sync.Mutex

func (s Server) SellStock(ctx context.Context, request *proto.StockRequest) (*emptypb.Empty, error) {
	// 加锁
	mutex.Lock()
	tx := db.DB.Begin()
	for _, info := range request.StockInfos {
		var stock model.Stock
		if result := tx.Where(&model.Stock{Goods: info.GoodsId}).First(&stock); result.RowsAffected == 0 {
			return nil, status.Error(codes.NotFound, "商品信息不存在")
		}
		if stock.Stocks < info.Num {
			// 库存不足 回滚事务
			tx.Rollback()
			return nil, status.Error(codes.ResourceExhausted, "库存不足")
		}
		stock.Stocks -= info.Num
		tx.Save(stock)
	}
	tx.Commit()
	// 解锁
	mutex.Unlock()
	return &emptypb.Empty{}, nil
}

client

package main

import (
	"context"
	"go-locks/process-lock/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"sync"
)

var client proto.StockClient

func main() {
	conn, err := grpc.Dial("127.0.0.1:8088", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		panic(err)
	}
	client = proto.NewStockClient(conn)
	var wg sync.WaitGroup
	wg.Add(20)
	for i := 0; i < 20; i++ {
		go TestSellStock(&wg)
	}
	wg.Wait()
}

func TestSellStock(wg *sync.WaitGroup) {
	defer wg.Done()
	_, err := client.SellStock(context.Background(), &proto.StockRequest{
		StockInfos: []*proto.StockInfo{
			{
				GoodsId: "123457",
				Num:     1,
			},
		},
	})
	if err != nil {
		panic(err)
	}
}

测试

在这里插入图片描述
单从这次结果上看是没有什么问题,但其实还是有问题的:

  1. 这里使用的锁,他是锁住的整块代码,不管进来的是那个商品都会要等待释放锁才能去获取锁执行,有很严重的性能问题
  2. 这里使用到的锁,是进程级别的锁,是go语言提供的锁,但是在真实的场景下都是多实例部署的,在多实例场景下,仍然会出现无锁时的问题

mysql悲观锁

悲观锁总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁

service

package service

import (
	context "context"
	"go-locks/pessimistic-lock/db"
	"go-locks/pessimistic-lock/model"
	"go-locks/pessimistic-lock/proto"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/emptypb"
	"gorm.io/gorm/clause"
)

type Server struct{}

func (s Server) SellStock(ctx context.Context, request *proto.StockRequest) (*emptypb.Empty, error) {
	tx := db.DB.Begin()
	for _, info := range request.StockInfos {
		var stock model.Stock
		// 通过for update 语句实现mysql的悲观锁
		if result := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where(&model.Stock{Goods: info.GoodsId}).First(&stock); result.RowsAffected == 0 {
			return nil, status.Error(codes.NotFound, "商品信息不存在")
		}
		if stock.Stocks < info.Num {
			// 库存不足 回滚事务
			tx.Rollback()
			return nil, status.Error(codes.ResourceExhausted, "库存不足")
		}
		stock.Stocks -= info.Num
		tx.Save(stock)
	}
	tx.Commit()
	return &emptypb.Empty{}, nil
}

client

package main

import (
	"context"
	"go-locks/pessimistic-lock/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"sync"
)

var client proto.StockClient

func main() {
	conn, err := grpc.Dial("127.0.0.1:8088", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		panic(err)
	}
	client = proto.NewStockClient(conn)
	var wg sync.WaitGroup
	wg.Add(20)
	for i := 0; i < 20; i++ {
		go TestSellStock(&wg)
	}
	wg.Wait()
}

func TestSellStock(wg *sync.WaitGroup) {
	defer wg.Done()
	_, err := client.SellStock(context.Background(), &proto.StockRequest{
		StockInfos: []*proto.StockInfo{
			{
				GoodsId: "123458",
				Num:     1,
			},
		},
	})
	if err != nil {
		panic(err)
	}
}

测试

在这里插入图片描述

mysql乐观锁

乐观锁顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，

service

package service

import (
	context "context"
	"go-locks/optimistic-lock/db"
	"go-locks/optimistic-lock/model"
	"go-locks/optimistic-lock/proto"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/emptypb"
	"log"
)

type Server struct{}

func (s Server) SellStock(ctx context.Context, request *proto.StockRequest) (*emptypb.Empty, error) {
	tx := db.DB.Begin()
	for _, info := range request.StockInfos {
		var stock model.Stock
		for {
			if result := db.DB.Where(&model.Stock{Goods: info.GoodsId}).First(&stock); result.RowsAffected == 0 {
				return nil, status.Error(codes.NotFound, "商品信息不存在")
			}
			if stock.Stocks < info.Num {
				// 库存不足 回滚事务
				tx.Rollback()
				return nil, status.Error(codes.ResourceExhausted, "库存不足")
			}
			stock.Stocks -= info.Num
			if result := tx.Model(&model.Stock{}).Select("Stocks", "Version").
				Where("goods = ? AND version = ?", info.GoodsId, stock.Version).Updates(&model.Stock{Stocks: stock.Stocks, Version: stock.Version + 1}); result.RowsAffected == 0 {
				// version 字段冲突;扣减失败
				log.Println("库存扣减失败;重试")
			} else {
				// 库存扣减成功
				log.Println("库存扣减成功")
				break
			}
		}
	}
	tx.Commit()
	return &emptypb.Empty{}, nil
}

client

package main

import (
	"context"
	"go-locks/optimistic-lock/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"sync"
)

var client proto.StockClient

func main() {
	conn, err := grpc.Dial("127.0.0.1:8088", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		panic(err)
	}
	client = proto.NewStockClient(conn)
	var wg sync.WaitGroup
	wg.Add(20)
	for i := 0; i < 20; i++ {
		go TestSellStock(&wg)
	}
	wg.Wait()
}

func TestSellStock(wg *sync.WaitGroup) {
	defer wg.Done()
	_, err := client.SellStock(context.Background(), &proto.StockRequest{
		StockInfos: []*proto.StockInfo{
			{
				GoodsId: "123459",
				Num:     1,
			},
		},
	})
	if err != nil {
		panic(err)
	}
}

测试

在这里插入图片描述

redis分布式锁

service

package service

import (
	context "context"
	"fmt"
	"go-locks/redis-lock/db"
	"go-locks/redis-lock/model"
	"go-locks/redis-lock/proto"
	"go-locks/redis-lock/redis"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/emptypb"
)

type Server struct{}

func (s Server) SellStock(ctx context.Context, request *proto.StockRequest) (*emptypb.Empty, error) {
	tx := db.DB.Begin()
	for _, info := range request.StockInfos {
		var stock model.Stock
		// 使用redis分布式锁,仅对当前商品进行加锁,不会影响其他商品
		mutex := redis.Redsy.NewMutex(fmt.Sprintf("goods_%s", info.GoodsId))
		if err := mutex.Lock(); err != nil {
			return nil, status.Error(codes.Internal, "获取redis分布式锁异常")
		}
		if result := tx.Where(&model.Stock{Goods: info.GoodsId}).First(&stock); result.RowsAffected == 0 {
			return nil, status.Error(codes.NotFound, "商品信息不存在")
		}
		if stock.Stocks < info.Num {
			// 库存不足 回滚事务
			tx.Rollback()
			return nil, status.Error(codes.ResourceExhausted, "库存不足")
		}
		stock.Stocks -= info.Num
		tx.Save(stock)
		if ok, err := mutex.Unlock(); !ok || err != nil {
			return nil, status.Error(codes.Internal, "释放redis分布式锁异常")
		}
	}
	tx.Commit()
	return &emptypb.Empty{}, nil
}

client

package main

import (
	"context"
	"go-locks/redis-lock/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"sync"
)

var client proto.StockClient

func main() {
	conn, err := grpc.Dial("127.0.0.1:8088", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		panic(err)
	}
	client = proto.NewStockClient(conn)
	var wg sync.WaitGroup
	wg.Add(20)
	for i := 0; i < 20; i++ {
		go TestSellStock(&wg)
	}
	wg.Wait()
}

func TestSellStock(wg *sync.WaitGroup) {
	defer wg.Done()
	_, err := client.SellStock(context.Background(), &proto.StockRequest{
		StockInfos: []*proto.StockInfo{
			{
				GoodsId: "123460",
				Num:     1,
			},
		},
	})
	if err != nil {
		panic(err)
	}
}

测试

在这里插入图片描述

总结

  • 无锁: 无锁即使在单机情况下也会出问题,不建议使用
  • 进程锁: 进程锁仅在单机情况下安全,性能存在瓶颈
  • mysql悲观锁: 分布式环境下安全.比较适合写入操作比较频繁的场景,如果出现大量的读取操作,每次读取的时候都会进行加锁,这样会增加大量的锁的开销,降低了系统的吞吐量.在特殊情况下还会升级成表锁,分布式环境下安全,但是性能依然存在瓶颈
  • mysql乐观锁: 分布式环境下安全,比较适合读取操作比较频繁的场景,如果出现大量的写入操作,数据发生冲突的可能性就会增大,为了保证数据的一致性,应用层需要不断的重新获取数据,这样会增加大量的查询操作,降低了系统的吞吐量.
  • redis分布式锁: 分布式环境下安全,并且redis有很好的性能,而且可以对单个商品进行加锁,只会阻塞住对同一商品的请求,并不会阻塞所有请求,大大提升了吞吐量
.番茄炒蛋
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
分布式锁与同步
禅与计算机程序设计艺术
10-27 99
随着互联网的蓬勃发展，网站在线人数越来越多，单个服务器无法支撑海量并发访问，而需要使用分布式集群部署。这种情况下，如何有效地管理并发访问对资源及数据的安全、稳定和正确性至关重要。为了解决这一难题，出现了很多基于锁或同步机制来控制共享资源访问的方案。比如，基于Paxos算法的分布式锁、基于消息队列的分布式同步等。这些方案都可以提供一定的保障，但仍然存在诸多不足之处，比如性能瓶颈、死锁风险、容错复杂度高等。因此，更加现代化的方法———基于数据库表的乐观锁或悲观锁就应运而生了。
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项目中分布式锁的使用（解决分布式锁超时的场景）
weixin_63800030的博客
01-21 1050
记录下项目中在接口中使用的分布式锁的目的和用法（使用了redsync库）
GO 分布式锁总结
szqqqqqqq的博客
04-04 1640
最近项目中需要实时计算一些数据，整体上是一个树的深度搜索过程，但是考虑到有并发请求的可能，同一时间只能允许有一个进行中的计算，防止最终数据的混乱。因此需要使用分布式锁来解决。因此自己总结了一下一些常见的方案，以及自己的实现。 在同一台机器上，我们可以通过多个进程共享某个互斥量等多种多样的方式，大体上是 测试并加锁 的逻辑，来实现对临界区的访问控制。对于分散的机器上的进程，也需要一个共享的协调者，只需要保证加锁和解锁对进程而言是一个原子操作即可。 首先贴一下...
Go语言实现Redis分布式锁
m0_57408211的博客
04-04 1102
本文将基于go语言，使用了一个常用的go Redis客户端一步一步探索与实现一个简单的Redis分布式锁。SETNX 命令用于在Redis中设置某个不存在的键的值。如果该键不存在，则设置成功，如果该键存在，则设置失败，不作任何动作。基于此可以实现一种简单的抢占机制。先连接redis。新建lock.go文件。创建lock结构体，加锁和解锁方法。
Go 语言实现高性能分布式锁
架构大师笔记
12-22 917
在分布式系统中，实现跨不同服务或节点的同步操作是一个常见的挑战。分布式锁提供了一种有效的机制来确保在分布式环境中只有一个进程或线程能执行特定的操作。本文将探讨在 Go 语言环境中实现分布式锁的原理和方法，包括使用 Redis 和 Etcd 作为锁的存储后端，并提供实际的代码示例。
详解一种用django_cache实现分布式锁的方式
01-01
基于缓存实现分布式锁，在网络上查找了实现方式，大概可以总结为以下3种： 第一种锁命令INCR 这种加锁的思路是， key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作进行加一。 然后其它用户在执行...
基于go和redis实现分布式锁
10-14
基于go和redis实现分布式锁，使用了看门狗和红锁
Go-用Redis实现分布式锁与实现任务队列
08-14
用Redis实现分布式锁 与 实现任务队列
go如何利用orm简单实现接口分布式锁
01-03
一旦没做锁，那么就真的会给用户多次提现，给公司带来损失。我来简单介绍一下在这种接口开发过程中，我的做法。 第一阶段: 我们使用的orm为xorm，提现表对应的结构体如下 type Participating struct { ID uint `...
Go必知必会系列：分布式锁与同步
禅与计算机程序设计艺术
09-28 869
作者：禅与计算机程序设计艺术 1.简介 “分布式系统”这个词汇在我们眼中似乎是高大上、神秘的词汇。如果你是软件开发人员或者架构师，那么你对分布式系统可能不陌生。但是如果你是一个工程师或者技术负责人，你或许对“分布式系统”这个词语有很多误解。我个人认为“分布式系统”是一个广义的概念，它可以定义成一组计算机
Go 分布式锁实现（Redis，ZK，etcd）
浅醉樱花雨的专栏
09-23 2417
6.2 分布式锁 在单机程序并发或并行修改全局变量时，需要对修改行为加锁以创造临界区。为什么需要加锁呢？我们看看在不加锁的情况下并发计数会发生什么情况： package main import ( "sync" ) // 全局变量 var counter int func main() { var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func() {
golang mysql加锁_[golang] 使用mysql及redis实现简单的分布式锁
weixin_29943753的博客
03-06 281
源码来自https://github.com/study-only/go-locksRedis分布式锁Redis SET 命令从Redis 2.6.12版本开始，SET命令的行为可以通过一系列参数来修改，详见Redis命令参考：SET key value [EX seconds] [PX milliseconds] [NX|XX]可选参数EX seconds：将键的过期时间设置为seconds秒。...
Go语言实现Redis分布式锁2
最新发布
m0_57408211的博客
04-08 828
注意，这里也是使用Lua脚本封装了确认锁与锁续期的操作来用于原子化，以防止误续期了其他持有者的锁。这里仍然存在一个问题：当锁的持有者任务未完成，但是锁的有效期已过，虽然持有者此时仍可以完成任务，并且也不会误删其他持有者的锁，但是此时可能会存在多个执行者同时执行临界区代码，使得数据的一致性难以保证，造成意外的后果，分布式锁就失去了意义。因此，需要一个锁的自动续期机制，分布式锁框架Redission中就有这么一个看门狗，专门为将要到期的锁进行续期。之前的是只尝试获取一次锁，要是获取失败就不再尝试了。
Go + Redis 实现分布式锁
J_Lee
03-09 5305
文章目录一、前言1.1 需要对交易订单加锁原因1.2 加锁方案二、Go + Redis 实现分布式锁2.1 为什么需要分布式锁2.2 分布式锁需要具备特性2.3 实现 Redis 锁应先掌握哪些知识点2.4 golang 连接redis2.5 golang + redis实现分布式锁2.6 总结 一、前言 1.1 需要对交易订单加锁原因 开始本篇文章分享之前，先简单进行一下项目描述。该项目为一个中心化钱包。java接收到用户的以太坊转账请求后，调用后端golang服务的转账接口，将交易发送至链上。 如果go
Golang实现分布式锁
何忆清风
01-09 1406
使用golang实现一个简易的分布式锁
go+redis分布式锁
哪吒的小橘猫
11-23 1306
使用Go+Redis实现分布式锁
golang 实现redis分布式锁
05-02
以下是一个简单的 Golang 实现 Redis 分布式锁的代码示例： ```go package redislock import ( "fmt" "time" "github.com/go-redis/redis/v7" ) type RedisLock struct { redisClient *redis.Client key ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

.番茄炒蛋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值