简单说说redis分布式锁

木子林_2024-02-03 22:50

什么是分布式锁

分布式锁（多服务共享锁）在分布式的部署环境下，通过锁机制来让多客户端互斥的对共享资源进行访问/操作。

为什么需要分布式锁

在单体应用服务里，不同的客户端操作同一个资源，我们可以通过操作系统提供的互斥（锁/信号量等等）来提供互斥的能力，保证操作资源的只有一个客户端。

在分布式的情况里，就需要第三方组件来保证对统一资源的操作的互斥。

（下单中，两个人下单，一个人下单请求走订单服务A机器，另一个人下单请求走订单服务B，这样用单体的思维处理就可能不是很合适，需要借用第三方组件配合来实现分布式锁）

分布式锁可以用redis, zookeeper ， etcd等等来实现，下面我们简单说说....

redis分布式锁

简单例子

set key value ex/px nx 或setnx

以setnx 为例，可以使用 setnx key value 来进行 "加锁" ( setnx 主要 是nx加了语义：如果存在就不操作，不存在就添加)，多个客户端确保只有一个加锁成功去操作统一资源

复制代码 
127.0.0.1:6379[1]> setnx lockObj 1   // 加锁
(integer) 1
127.0.0.1:6379[1]> setnx lockObj 1  // 存在了就不能再加锁
(integer) 0
127.0.0.1:6379[1]> get lockObj
"1"
127.0.0.1:6379[1]> del lockObj // 释放锁
(integer) 1
127.0.0.1:6379[1]> get lockObj
(nil)
127.0.0.1:6379[1]> setnx lockObj 1
(integer) 1

上面就是简单的加锁的例子，仔细思考下分布式锁使用的使用我们需要考虑哪些问题？

存在的问题

简单的总结了下，我们在使用redis分布式锁的时候需要考虑如下情况：

1- 死锁问题

2- 续锁生命周期

3- 操作原子性

4- 锁的归属权

5- redis 集群，锁的状态一致性

死锁问题

如果我们业务代码出现bug或服务器出现问题，没有及时释放锁，那么其他的客户端就永远获取不到这个加锁的资格。

这个时候我们就可以加上对应的处理逻辑：

golang 加上defer 加锁锁逻辑 ， python try-Except-finally 用finally 释放锁。并且在加锁的时候加上过期时间（根据业务进行合适的加）

续锁生命周期

上面我们可以解决锁的释放问题，但是我们的业务处理时间不一定百分百能知道处理的时间，这个时候如果锁过期了但是资源操作没有做完，那么就会出现问题。

在java的 Redisson 有个watch 续命机制， golang 的话可以 借鉴 Rllock ，开启一个守护进程监听，定时续命（一定要提前续命，不要等到到时间再续）

操作原子性

在我们进行加锁 加过期时间的时候，这两个操作不能分两步操作。因为如果setnx加锁成功了，这时候失败了，那么这个锁就永远被占用了。

根据这个问题我们可以使用lua脚本或者使用第三方模块是可以同时进行这两个步骤的

复制代码 
`if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then return redis.call('PEXPIRE',KEYS[1],ARGV[2]) else return 0 end`

锁的归属权问题

现在有几个场景：

1- 客户端1 拿到锁处理业务， 没处理完已经过期了；这时候客户端2 拿到锁在处理，结果客户端1 处理完就释放锁了

2- 一个业务不同画像的人处理的业务不同，这时候我们就需要根据不同画像人进行分配 "锁"

我们在实际开发的时候有时候需要了解业务场景， 有时候需要给锁加一个所属权的令牌。可以在setnx key时，key设定特殊化的数值

redis 集群，锁的状态一致性

在redis采用集群（主从），如果master加锁失败了，这时候服务宕机了，slave还同步这个 key ，那么这个时候就会有客户端加锁成功

redis作者对于这个问题提出了解答：REDLOCK

zookeeper 实现分布式锁

简单例子

复制代码 
[zk: localhost:2181(CONNECTED) 62] create  /lock 
Created /lock
[zk: localhost:2181(CONNECTED) 63] create -s -e /lock/req  // 创建临时节点
Created /lock/req0000000000 
[zk: localhost:2181(CONNECTED) 64] create -s -e /lock/req
Created /lock/req0000000001
[zk: localhost:2181(CONNECTED) 65] create -s -e /lock/req
Created /lock/req0000000002
[zk: localhost:2181(CONNECTED) 67] ls /lock // 节点下的临时节点
[req0000000000, req0000000001, req0000000002] 
[zk: localhost:2181(CONNECTED) 68] delete /lock/req0000000000 // 释放第一锁

golang的例子

Go 复制代码 
package main

import (
    "fmt"
    "github.com/samuel/go-zookeeper/zk"
    "sort"
    "time"
)

func sortChildren(children []string) {
    sort.Slice(children, func(i, j int) bool {
        return children[i] < children[j]
    })
}
func main() {
    go func() {
        conn, _, err := zk.Connect([]string{"xx.xx.xx.xx:2181"}, time.Second*5)
        if err != nil {
            fmt.Println("Connect:", err.Error())
            return
        }
        defer conn.Close()

        lockPath := "/locksObj"
        lockName := "lock"

        // 创建锁的根节点
        _, err = conn.Create(lockPath, []byte{}, int32(0), zk.WorldACL(zk.PermAll))
        if err != nil && err != zk.ErrNodeExists {
            fmt.Println("Create:", err.Error())
            return
        }

        // 获取锁
        lockNodePath, err := conn.CreateProtectedEphemeralSequential(lockPath+"/"+lockName+"-", []byte{}, zk.WorldACL(zk.PermAll))
        if err != nil {
            fmt.Println("CreateProtectedEphemeralSequential:", err.Error())
            return
        }
        // dowork

        for {
            children, _, err := conn.Children(lockPath)
            if err != nil {
                fmt.Println("Children:", err.Error())
                return
            }

            // 对子节点按照序列号进行排序
            sortChildren(children)

            // 检查自己创建的节点是否是第一个节点
            if lockNodePath == lockPath+"/"+children[0] {
                // 获取到了锁
                fmt.Println("Acquired lock")
                break
            }

            // 监听前一个节点的删除事件
            exists, _, watch, err := conn.ExistsW(lockPath + "/" + children[0])
            if err != nil {
                fmt.Println("ExistsW: ", err.Error())
                break
            }

            if !exists {
                // 前一个节点已删除，再次检查自己创建的节点是否是第一个节点
                children, _, err = conn.Children(lockPath)
                if err != nil {
                    fmt.Println("Children: ", err.Error())
                    break
                }

                sortChildren(children)

                if lockNodePath == lockPath+"/"+children[0] {
                    // 获取到了锁
                    fmt.Println("Acquired lock")
                    break
                }
            }

            // 等待前一个节点的删除事件
            <-watch
        }

        // 执行需要保护的代码
        fmt.Println("====start-1====")

        time.Sleep(3 * time.Second)
        fmt.Println(11111111)

        // 释放锁，删除自己创建的节点
        err = conn.Delete(lockNodePath, -1)
        if err != nil {
            fmt.Println("Delete: ", err.Error())
            return
        }

        fmt.Println("Released lock")
    }()
    go func() {
        conn, _, err := zk.Connect([]string{"xx.xx.xx.xx:2181"}, time.Second*5)
        if err != nil {
            fmt.Println("Connect:", err.Error())
            return
        }
        defer conn.Close()

        lockPath := "/locksObj"
        lockName := "lock"

        // 创建锁的根节点
        _, err = conn.Create(lockPath, []byte{}, int32(0), zk.WorldACL(zk.PermAll))
        if err != nil && err != zk.ErrNodeExists {
            fmt.Println("Create:", err.Error())
            return
        }

        // 获取锁
        lockNodePath, err := conn.CreateProtectedEphemeralSequential(lockPath+"/"+lockName+"-", []byte{}, zk.WorldACL(zk.PermAll))
        if err != nil {
            fmt.Println("CreateProtectedEphemeralSequential:", err.Error())
            return
        }

        for {
            children, _, err := conn.Children(lockPath)
            if err != nil {
                fmt.Println("Children:", err.Error())
                return
            }

            // 对子节点按照序列号进行排序
            sortChildren(children)

            // 检查自己创建的节点是否是第一个节点
            if lockNodePath == lockPath+"/"+children[0] {
                // 获取到了锁
                fmt.Println("Acquired lock")
                break
            }

            // 监听前一个节点的删除事件
            exists, _, watch, err := conn.ExistsW(lockPath + "/" + children[0])
            if err != nil {
                fmt.Println("ExistsW: ", err.Error())
                break
            }

            if !exists {
                // 前一个节点已删除，再次检查自己创建的节点是否是第一个节点
                children, _, err = conn.Children(lockPath)
                if err != nil {
                    fmt.Println("Children: ", err.Error())
                    break
                }

                sortChildren(children)

                if lockNodePath == lockPath+"/"+children[0] {
                    // 获取到了锁
                    fmt.Println("Acquired lock")
                    break
                }
            }

            // 等待前一个节点的删除事件
            <-watch
        }

        // 执行需要保护的代码
        fmt.Println("====start-2====")

        time.Sleep(5 * time.Second)
        fmt.Println(22222222)
        // 释放锁，删除自己创建的节点
        err = conn.Delete(lockNodePath, -1)
        if err != nil {
            fmt.Println("Delete: ", err.Error())
            return
        }

        fmt.Println("Released lock")
    }()
    time.Sleep(10 * time.Second)
}

zookeeper 怎么实现 分布式锁的

zookeeper 会建立一个长链接，监听锁对象节点的状态和事件

ETCD实现 分布式锁

简单实现

Go 复制代码 
package main

import (
	"context"
	"fmt"
	clientv3 "go.etcd.io/etcd/client/v3"
	"time"
)


func main() {
	go func() {
		config := clientv3.Config{
			Endpoints:   []string{"xx.xx.xx.xx:2379"},
			DialTimeout: 5 * time.Second,
		}

		// 获取客户端连接
		client, err := clientv3.New(config)
		if err != nil {
			fmt.Println(err)
			return
		}

		//  上锁
		// 用于申请租约
		lease := clientv3.NewLease(client)

		// 申请一个10s的租约
		leaseGrantResp, err := lease.Grant(context.TODO(), 10) //10s
		if err != nil {
			fmt.Println(err)
			return
		}

		// 拿到租约的id
		leaseID := leaseGrantResp.ID

		ctx, cancelFunc := context.WithCancel(context.TODO())

		// 停止
		defer cancelFunc()
		// 确保函数退出后，租约会失效
		defer lease.Revoke(context.TODO(), leaseID)

		// 自动续租
		keepRespChan, err := lease.KeepAlive(ctx, leaseID)
		if err != nil {
			fmt.Println(err)
			return
		}

		// 处理续租应答的协程
		go func() {
			select {
			case keepResp := <-keepRespChan:
				if keepRespChan == nil {
					fmt.Println("lease has expired")
					break
				} else {
					// 每秒会续租一次
					fmt.Println("收到自动续租应答", keepResp.ID)
				}
			}
		}()

		// if key 不存在，then设置它，else抢锁失败
		kv := clientv3.NewKV(client)
		// 创建事务
		txn := kv.Txn(context.TODO())
		// 如果key不存在
		txn.If(clientv3.Compare(clientv3.CreateRevision("/lockObj/lock/job"), "=", 0)).
			Then(clientv3.OpPut("/lockObj/lock/job", "", clientv3.WithLease(leaseID))).
			Else(clientv3.OpGet("/lockObj/lock/job")) //如果key存在

		// 提交事务
		txnResp, err := txn.Commit()
		if err != nil {
			fmt.Println(err)
			return
		}

		// 判断是否抢到了锁
		if !txnResp.Succeeded {
			fmt.Println("锁被占用了：", string(txnResp.Responses[0].GetResponseRange().Kvs[0].Value))
			return
		}

		// 处理业务

		fmt.Println("======work======")
		time.Sleep(5 * time.Second)
		fmt.Println("======END======")


	}()
	time.Sleep(20 * time.Second)
}

实现原理

etcd 支持以下功能，正是依赖这些功能来实现分布式锁的：

  • Lease机制：即租约机制(TTL,Time To Live)，etcd可以为存储的kv对设置租约，当租约到期，kv将失效删除；同时也支持续约，keepalive
  • Revision机制：每个key带有一个Revision属性值，etcd每进行一次事务对应的全局Revision值都会+1，因此每个key对应的Revision属性值都是全局唯一的。通过比较Revision的大小就可以知道进行写操作的顺序
  • 在实现分布式锁时，多个程序同时抢锁，根据Revision值大小依次获得锁，避免"惊群效应"，实现公平锁
  • Prefix机制：也称为目录机制，可以根据前缀获得该目录下所有的key及其对应的属性值
  • watch机制：watch支持watch某个固定的key或者一个前缀目录，当watch的key发生变化，客户端将收到通知

执行流程

  • 步骤 1: 准备

客户端连接 Etcd，以 /lock/mylock 为前缀创建全局唯一的 key，假设第一个客户端对应的 key="/lock/mylock/UUID1"，第二个为 key="/lock/mylock/UUID2"；客户端分别为自己的 key 创建租约 - Lease，租约的长度根据业务耗时确定，假设为 15s；

  • 步骤 2: 创建定时任务作为租约的"心跳"

当一个客户端持有锁期间，其它客户端只能等待，为了避免等待期间租约失效，客户端需创建一个定时任务作为"心跳"进行续约。此外，如果持有锁期间客户端崩溃，心跳停止，key 将因租约到期而被删除，从而锁释放，避免死锁。

  • 步骤 3: 客户端将自己全局唯一的 key 写入 Etcd

进行 put 操作，将步骤 1 中创建的 key 绑定租约写入 Etcd，根据 Etcd 的 Revision 机制，假设两个客户端 put 操作返回的 Revision 分别为 1、2，客户端需记录 Revision 用以接下来判断自己是否获得锁。

  • 步骤 4: 客户端判断是否获得锁

客户端以前缀 /lock/mylock 读取 keyValue 列表（keyValue 中带有 key 对应的 Revision），判断自己 key 的 Revision 是否为当前列表中最小的，如果是则认为获得锁；否则监听列表中前一个 Revision 比自己小的 key 的删除事件，一旦监听到删除事件或者因租约失效而删除的事件，则自己获得锁。

  • 步骤 5: 执行业务

获得锁后，操作共享资源，执行业务代码。

  • 步骤 6: 释放锁

完成业务流程后，删除对应的key释放锁。

扩展

马丁·克莱普曼 对 分布式锁以及对redlock的看法

分布式锁的目的是确保在可能尝试执行同一工作的多个节点中，只有一个节点实际执行该操作（至少一次只有一个）。

主要有两个功能：

1- 效率：使用锁可以避免不必要地重复相同的工作，多执行一次也无妨，只要最终正确就行

2- 正确性：锁定可以防止并发进程互相干扰并扰乱系统状态。如果锁定失败并且两个节点同时处理同一数据，则会导致文件损坏、数据丢失、永久不一致。

马丁认为锁在分布式系统使用会碰到以下三类问题：

1- 网络延迟：您可以保证数据包始终在某个保证的最大延迟内到达

2- GC问题： 导致锁无法续期等等问题

3- 时钟飘移：依赖于时钟的就容易出现问题

马丁认为redlock 强依赖于时钟，节点之间时钟不对，会使锁不可靠：

假设系统有五个 Redis 节点（A、B、C、D 和 E）和两个客户端（1 和 2）。如果其中一个 Redis 节点上的时钟向前跳动，会发生什么情况？

  1. 客户端 1 获取节点 A、B、C 上的锁。由于网络问题，无法访问 D 和 E。
  2. 节点C上的时钟向前跳跃，导致锁过期。
  3. 客户端2获取节点C、D、E上的锁。由于网络问题，无法访问A和B。
  4. 客户 1 和 2 现在都相信他们持有锁。

如果 C 在将锁持久保存到磁盘之前崩溃并立即重新启动，则可能会发生类似的问题。因此，Redlock 文档建议延迟重新启动崩溃的节点，至少要延迟最长寿命锁的生存时间。但这种重新启动延迟再次依赖于对时间的相当准确的测量，并且如果时钟跳跃就会失败。

马丁提出了 fencing token 方案

客户端 1 获取租约并获得令牌 33，但随后它进入长时间暂停状态并且租约到期。客户端 2 获取租约，获取令牌 34（数字始终增加），然后将其写入发送到存储服务，包括 34 的令牌。稍后，客户端 1 恢复正常并将其写入发送到存储服务，包括其令牌值 33。但是，存储服务器记得它已经处理了具有更高令牌编号 (34) 的写入，因此它拒绝具有令牌 33 的请求。

总结

分布式锁不是百分百安全，我们要根据实际使用情况来考虑锁的使用（解决效率问题还是正确行问题），在使用分布式锁的时候我们需要考虑锁的续期，锁归属，集群数据一致性，操作原子性，GC，时钟飘逸，网络延迟等等的问题。在cap 理论里， redis保证了ap, zk和etcd保证cp ,所以实际使用中根据业务的情况，选择redis/zk/etcd之一来实现分布式锁。

相关推荐
柯南二号6 小时前
MacOS 用brew 安装、配置、启动Redis
redis
星星点点洲9 小时前
【Redis】RedLock实现原理
redis·缓存
我来整一篇9 小时前
用Redis的List实现消息队列
数据库·redis·list
加什么瓦9 小时前
Redis——数据结构
数据库·redis·缓存
lybugproducer10 小时前
浅谈 Redis 数据类型
java·数据库·redis·后端·链表·缓存
青山是哪个青山10 小时前
Redis 常见数据类型
数据库·redis·bootstrap
杨不易呀10 小时前
Java面试全记录：Spring Cloud+Kafka+Redis实战解析
redis·spring cloud·微服务·kafka·高并发·java面试·面试技巧
morris13111 小时前
【redis】CacheAside的数据不一致性问题
redis·缓存策略·cache aside·数据不一致性
wjcurry12 小时前
我的实习日报
java·redis·mysql
热门推荐
01YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03KGG转MP3工具|非KGM文件|解密音频04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05Coze扣子平台完整体验和实践（附国内和国际版对比）06DeepSeek各版本说明与优缺点分析07VMware虚拟机安装Win7专业版保姆级教程（附镜像包）08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09苍穹外卖面试总结10PyCharm 无法识别 Conda 环境的解决方案