正文
其实锁这种东西，都能能不加就不加，锁会导致程序一定程度上退回到串行化，进而降低效率。
案例
首先，看一个案例，如果要实现一个计数器，并且是多个协程共同进行
正文
其实锁这种东西，都能能不加就不加，锁会导致程序一定程度上退回到串行化，进而降低效率。
案例
首先，看一个案例，如果要实现一个计数器，并且是多个协程共同进行的，就会出现以下的情况：
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 分布式锁的资料请关注好代码网其它相关文章！
