go 分布式锁简单实现实例详解
更新时间：2022年09月15日 15:07:40 作者：水纹
这篇文章主要为大家介绍了go 分布式锁简单实现实例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
正文
其实锁这种东西，都能能不加就不加，锁会导致程序一定程度上退回到串行化，进而降低效率。
案例
首先，看一个案例，如果要实现一个计数器，并且是多个协程共同进行的，就会出现以下的情况：
package main
import (
"fmt"
"sync"
)
func main() {
numberFlag := 0
wg := new(sync.WaitGroup)
for i := 0; i < 200; i++ {
wg.Add(1)
go func() {
defer wg.Done()
numberFlag++
}()
}
fmt.Println(numberFlag)
wg.Wait()
}
每次执行后的计数器结果都是不同的，这是因为计数器本身是被不同的协程抢着+1，会产生多个协程同时拿到numberFlag=N的情况。为了避免这种资源竞争，要对资源进行加锁，使得同一时刻只有一个协程能对资源进行操控。
资源加锁
package main
import (
"fmt"
"sync"
)
func main() {
numberFlag := 0
myLock := make(chan struct{}, 1)
wg := new(sync.WaitGroup)
for i := 0; i < 200; i++ {
wg.Add(1)
go func() {
defer func() {
// 释放锁
<-myLock
}()
defer wg.Done()
// 抢锁
myLock <- struct{}{}
numberFlag++
}()
}
wg.Wait()
fmt.Println(numberFlag)
}
但是这种锁只能用于你自己的本地服务，一旦出现多服务，比如分布式，微服务，这样的场景，这个锁就没啥用了，这就需要分布式锁。
关于分布式锁，一般的实现就是用redis或者zookeeper实现。redis比较方便的就是大部分的服务都会使用redis，无需额外安装依赖，而zookeeper普通服务用的并不多，即使是kafka也在新版放弃了zookeeper。
zookeeper最大的好处就是可以通过心跳检测客户端的情况，进而避免重复得锁的问题。
但是同时也产生了一些问题，这个心跳检测多久一次，在心跳检测的间隔如果出现了锁超时的问题怎么办，等等。
使用redis来实现分布式锁
所以一些服务还是倾向于使用redis来实现分布式锁。
package main
import (
"fmt"
"github.com/gomodule/redigo/redis"
"go-face-test/redisTest/redisOne/redisConn"
"sync"
"time"
)
func main() {
// 分布式锁
var LockName = "lockLock"
// 十秒过期时间
var ExpirationTime = 10
wg := new(sync.WaitGroup)
wg.Add(2)
// 起两个协程来模拟分布式服务的抢占
go handleBusiness(LockName, ExpirationTime, "A", wg)
go handleBusiness(LockName, ExpirationTime, "B", wg)
wg.Wait()
}
func handleBusiness(lockName string, ExpTime int, nowGroName string, wg *sync.WaitGroup) {
// One服务获取锁是否存在
c := redisConn.Get()
defer c.Close()
for {
isKeyExists, err := redis.Bool(c.Do("EXISTS", lockName))
if err != nil {
fmt.Println("err while checking keys:", err)
} else {
fmt.Println(isKeyExists)
}
if isKeyExists {
// 存在这把锁，开始自旋等待
fmt.Println("当前协程为: " + nowGroName + " 没抢到锁……")
//休息1s
time.Sleep(time.Second)
} else {
// 设置一把锁
// 值为1，过期时间为10秒
reply, err := c.Do("SET", lockName, 2, "EX", ExpTime, "NX")
// 抢占失败
if reply == nil {
fmt.Println("当前协程为: " + nowGroName + " 抢占锁失败")
continue
}
// 开始业务处理
fmt.Println("当前协程为: " + nowGroName + " 啊啊啊啊。这是一个业务处理，预计处理时间为 3s 。处理开始........")
fmt.Println("当前协程为: " + nowGroName + " 距离处理完成还有---3s" + time.Now().Format("2006-01-02 15:04:05"))
time.Sleep(time.Second)
fmt.Println("当前协程为: " + nowGroName + " 距离处理完成还有---2s" + time.Now().Format("2006-01-02 15:04:05"))
time.Sleep(time.Second)
fmt.Println("当前协程为: " + nowGroName + " 距离处理完成还有---1s" + time.Now().Format("2006-01-02 15:04:05"))
time.Sleep(time.Second)
//业务结束,释放锁
_, err = c.Do("DEL", lockName)
if err != nil {
fmt.Println("err while deleting:", err)
}
break
}
}
wg.Done()
}
但是这个锁明显有问题:
第一，当A服务（本案例中其实是协程模拟的）拿到锁之后，处理超时了，锁还没有释放，就已经过期，过期后B服务就抢到了锁，此时AB均认为自己拿到了锁
第二，A服务按理说只能去掉自己的服务加上的锁，如果不止是有AB两个服务，有更多的服务，那么A如果出现处理较慢，锁超时后，B服务抢到锁，A又处理完成所有的事释放了锁，那其实是释放掉了B的锁。
也就是说，释放锁的时候也必须判断是否是自己的锁
那么就得用redis的lua来保证原子性
redis lua保证原子性
package main
import (
"fmt"
"github.com/gomodule/redigo/redis"
"go-face-test/redisTest/redisTwo/redisConn"
"log"
"math/rand"
"strconv"
"sync"
"time"
)
var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
var lockCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
redis.call("SET", KEYS[1], ARGV[1], "PX", ARGV[2] , "NX")
return "OK"
else
return redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2])
end`
var delCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
return redis.call("DEL", KEYS[1])
else
return 0
end`
func main() {
// 分布式锁
var LockName = "lockLock"
// 十秒过期时间
var ExpirationTime = 3
wg := new(sync.WaitGroup)
wg.Add(2)
// 起两个协程来模拟分布式服务的抢占
go handleBusiness(LockName, ExpirationTime, "A", wg)
go handleBusiness(LockName, ExpirationTime, "B", wg)
wg.Wait()
}
func init() {
rand.Seed(time.Now().UnixNano())
}
func handleBusiness(lockName string, ExpTime int, nowGroName string, wg *sync.WaitGroup) {
// One服务获取锁是否存在
c := redisConn.Get()
defer c.Close()
for {
isKeyExists, err := redis.Bool(c.Do("EXISTS", lockName))
if err != nil {
fmt.Println("err while checking keys:", err)
} else {
fmt.Println(isKeyExists)
}
if isKeyExists {
// 存在这把锁，开始自旋等待
fmt.Println("当前协程为: " + nowGroName + " 没抢到锁……")
//休息1s
time.Sleep(time.Second)
} else {
// 设置一把锁
// 锁的值是根据当前服务名称和时间来的
lockFlag, lockValue, _ := getLock(lockName, nowGroName, ExpTime, c)
// 抢占失败
if !lockFlag {
fmt.Println("当前协程为: " + nowGroName + " 抢占锁失败")
continue
}
// 开始业务处理
fmt.Println("当前协程为: " + nowGroName + " 啊啊啊啊。这是一个业务处理，预计处理时间为 " + strconv.Itoa(ExpTime) + "s 。处理开始........")
for i := ExpTime - 1; i > 0; i-- {
fmt.Println("当前协程为: " + nowGroName + " 距离处理完成还有---" + strconv.Itoa(i) + "s " + time.Now().Format("2006-01-02 15:04:05"))
time.Sleep(time.Second)
}
//业务结束,释放锁
lockDelFlag, _ := delLock(lockName, lockValue, c)
//获取当前锁的值
if lockDelFlag {
fmt.Println("释放锁成功")
} else {
fmt.Println("这个锁不是你的，或者这个锁已经超时")
}
break
}
}
wg.Done()
}
// 获得唯一锁的值
func getLockOnlyValue(nowGroName string) string {
nano := strconv.FormatInt(time.Now().UnixNano(), 10)
return nowGroName + "_" + nano + "_" + RandStringRunes(6)
}
// 获得一个锁
func getLock(LockName, nowGroName string, timeOut int, conn redis.Conn) (bool, string, error) {
myLockValue := getLockOnlyValue(nowGroName)
lua := redis.NewScript(1, lockCommand)
resp, err := lua.Do(conn, LockName, myLockValue, strconv.Itoa(timeOut*1000))
if err != nil {
log.Fatal(LockName, err)
return false, "", err
} else if resp == nil {
return false, "", nil
}
s, ok := resp.(string)
if !ok {
return false, "", nil
}
if s != "OK" {
return false, "", nil
}
return true, myLockValue, nil
}
// 删除一个锁
func delLock(LockName, LockeValue string, conn redis.Conn) (bool, error) {
lua := redis.NewScript(1, delCommand)
resp, err := lua.Do(conn, LockName, LockeValue)
if err != nil {
return false, err
}
reply, ok := resp.(int64)
if !ok {
return false, nil
}
return reply == 1, nil
}
func RandStringRunes(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letterRunes[rand.Intn(len(letterRunes))]
}
return string(b)
}以上就是go 分布式锁简单实现实例详解的详细内容，更多关于go 分布式锁的资料请关注脚本之家其它相关文章！
相关文章
这篇文章主要为大家介绍了Go日志框架zap增强及源码解读，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-07-07
这篇文章主要为大家介绍了go语言中基本数据类型应用详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-07-07
这篇文章主要为大家介绍了GoFrame实现顺序性校验示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-06-06
go install和go get都是Go语言的工具命令，但它们之间有一些区别。go get：用于从远程代码存储库（如 GitHub）中下载或更新Go代码包。go install：用于编译并安装 Go 代码包，本文go get和go install对比介绍的非常详细，需要的朋友可以参考一下2023-04-04
Golang是一种简洁、高效的编程语言,它的强大并发性能和丰富的标准库使得它成为了开发硬件驱动的理想选择,在本文中,我们将探讨如何使用Golang开发硬件驱动程序,并提供一个实例来帮助你入门,需要的朋友可以参考下2023-11-11
本文介绍了如何使用GO语言和client-go库处理YAML文件,特别是在Kubernetes环境下,分析了YAML的特点,如简洁性、易读性、可嵌套性等,并展示了相关代码实现,包括单文档和多文档的处理方法,感兴趣的可以了解一下2024-10-10
这篇文章主要为大家介绍了Go语言入门Go Web Fiber框架的示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-05-05
这篇文章主要介绍了Golang使用CGO与Plugin技术运行加载C动态库，Golang 程序在运行时加载C动态库的技术，跳过了Golang项目编译阶段需要链接C动态库的过程，提高了Golang项目开发部署的灵活性2022-07-07
本文给大家分享的是一段GO语言利用K近邻算法实现小说鉴黄的方法，本方法的鉴别的关键是关键是向量点的选择和阈值的判定，推荐给大家，有需要的小伙伴可以参考下。2015-03-03
Go语言同步与异步执行多个任务封装详解(Runner和RunnerAsync)
这篇文章主要给大家介绍了关于Go语言同步与异步执行多个任务封装(Runner和RunnerAsync)的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。2018-01-01
最新评论