在分布式系统中，协调多个服务实例之间的共享资源访问是一个经典的挑战。传统的单机锁（如

1. sync.Mutex

复制代码

）无法实现跨进程工作，此时就需要用到分布式锁了。本文将介绍 Go 语言生态中基于 Redis 实现的分布式锁库

1. redsync

复制代码

，并探讨其使用方法和实现原理。

分布式锁

首先我们来探讨下为什么需要分布式锁？当我们编写的程序出现资源竞争的时候，就需要使用互斥锁来保证并发安全。而我们的服务很有可能不会单机部署，而是采用多副本的集群部署方案。无论哪种方案运行程序，我们都需要合适的工具来解决并发问题。在解决单个进程间多个协程之间的并发资源抢占问题时，我们往往采用

1. sync.Mutex

复制代码

。而在解决多个进程间的并发资源抢占问题时，就需要采用分布式锁了，这就引出了我们今天要讲解的

1. redsync

复制代码

。
为什么是 redsync
在 Go 中分布式锁的开源实现有很多，为什么选择介绍和使用

1. redsync

复制代码

呢？简单一句话：

1. redsync

复制代码

是 Redis 官方 唯一推荐的 Go Redis 分布式锁解决方案，遵循 Redlock 算法。它允许在多个独立 Redis 节点上创建高可用的锁，适用于需要强一致性的分布式场景。
我们可以对比下

1. sync.Mutex

复制代码

和

1. redsync

复制代码

之间的区别，让你有个感性的认识。
特性sync.Mutexredsync适用范围单个进程内的多个 goroutine多个进程（允许跨机器）依赖无Redis性能高（无网络开销）较低（涉及网络通信）实现复杂度简单较复杂（需处理网络、超时等问题）典型场景内存共享资源保护分布式系统共享资源保护二者分别适用于不同的并发场景，选择时需要根据实际需求（单机还是分布式）来决定。

redsync 快速上手

1. redsync

复制代码

虽然内部实现上比较复杂，但别被吓到，它的用法超级简单。
示例代码如下：

1. package main
   
2. 
   
3. import (
   
4.         "context"
   
5. 
   
6.         "github.com/go-redsync/redsync/v4"                  // 引入 redsync 库，用于实现基于 Redis 的分布式锁
   
7.         "github.com/go-redsync/redsync/v4/redis/goredis/v9" // 引入 redsync 的 goredis 连接池
   
8.         goredislib "github.com/redis/go-redis/v9"           // 引入 go-redis 库，用于与 Redis 服务器通信
   
9. )
   
10. 
    
11. func main() {
    
12.         // 创建一个 Redis 客户端
    
13.         client := goredislib.NewClient(&goredislib.Options{
    
14.                 Addr:     "localhost:36379", // Redis 服务器地址
    
15.                 Password: "nightwatch",
    
16.         })
    
17. 
    
18.         // 使用 go-redis 客户端创建一个 redsync 连接池
    
19.         pool := goredis.NewPool(client)
    
20. 
    
21.         // 创建一个 redsync 实例，用于管理分布式锁
    
22.         rs := redsync.New(pool)
    
23. 
    
24.         // 创建一个名为 "test-redsync" 的互斥锁（Mutex）
    
25.         mutex := rs.NewMutex("test-redsync")
    
26. 
    
27.         // 创建一个上下文（context），一般用于控制锁的超时和取消
    
28.         ctx := context.Background()
    
29. 
    
30.         // 获取锁，如果获取失败（例如锁已被其他进程持有），会返回错误
    
31.         if err := mutex.LockContext(ctx); err != nil {
    
32.                 panic(err) // 如果获取锁失败，程序会 panic
    
33.         }
    
34. 
    
35.         // TODO 执行业务逻辑
    
36.         // ...
    
37. 
    
38.         // 释放锁，如果释放失败（例如锁已过期或不属于当前进程），会返回错误
    
39.         if _, err := mutex.UnlockContext(ctx); err != nil {
    
40.                 panic(err) // 如果释放锁失败，程序会 panic
    
41.         }
    
42. }

复制代码

因为

1. redsync

复制代码

依赖 Redis，所以我们首先需要创建一个 Redis 客户端对象

1. client

复制代码

，调用

1. goredis.NewPool(client)

复制代码

会基于这个

1. client

复制代码

创建一个

1. redsync

复制代码

的连接池，有了这个连接池

1. pool

复制代码

就可以调用

1. redsync.New(pool)

复制代码

创建一个

1. redsync

复制代码

实例来申请分布式锁了。

1. redsync

复制代码

提供了

1. NewMutex

复制代码

方法可以创建一个分布式锁，它接收一个

1. name

复制代码

参数作为锁的名字，这个名字会作为 Redis 中的

1. key

复制代码

。
拿到锁对象

1. mutex

复制代码

以后，调用

1. mutex.LockContext(ctx)

复制代码

就可以加锁，加锁后便可以访问竞态资源了，资源访问完成后，调用

1. mutex.UnlockContext(ctx)

复制代码

便可以释放锁。
可以发现，

1. redsync

复制代码

用法和

1. sync.Mutex

复制代码

非常相似，核心就是

1. Lock/Unlock

复制代码

两个操作。redsync 的使用无非多了一步连接 Redis 的过程。

配置选项

不知道你有没有想过一个问题，我们在使用

1. sync.Mutex

复制代码

时，如果某个 gorutine 加锁后不释放掉，那么其他 gorutine 就无法获取锁，而在分布式场景中，如果一个进程获取了 Redis 分布式锁，然后在未释放锁之前进程挂掉了，其他进程要如何获取锁呢，难道要一直等待下去吗？
这里就要引出一个使用分布式锁很重要的问题，那就是一定要设置一个过期时间，这样才能保证即使拿到锁的进程挂掉了，只要锁的过期时间已到，锁也一定会被自动释放掉，只有这样，其他进程才有机会获取锁。
而我们上面的示例中，之所以可以不设置锁的过期时间，原因是

1. redsync

复制代码

内部设置了默认值。以下是

1. redsync

复制代码

中

1. NewMutex

复制代码

方法的源码：

1. // NewMutex returns a new distributed mutex with given name.
   
2. func (r *Redsync) NewMutex(name string, options ...Option) *Mutex {
   
3.         m := &Mutex{
   
4.                 name:   name,
   
5.                 expiry: 8 * time.Second,
   
6.                 tries:  32,
   
7.                 delayFunc: func(tries int) time.Duration {
   
8.                         return time.Duration(rand.Intn(maxRetryDelayMilliSec-minRetryDelayMilliSec)+minRetryDelayMilliSec) * time.Millisecond
   
9.                 },
   
10.                 genValueFunc:  genValue,
    
11.                 driftFactor:   0.01,
    
12.                 timeoutFactor: 0.05,
    
13.                 quorum:        len(r.pools)/2 + 1,
    
14.                 pools:         r.pools,
    
15.         }
    
16.         for _, o := range options {
    
17.                 o.Apply(m)
    
18.         }
    
19.         if m.shuffle {
    
20.                 randomPools(m.pools)
    
21.         }
    
22.         return m
    
23. }

复制代码

这里

1. Mutex

复制代码

对象的第二个字段

1. expiry

复制代码

就是分布式锁的过期时间，这里默认为设为 8 秒。

1. tries

复制代码

字段是获取锁的重试次数，即尝试获取锁失败 32 次以后，才会返回加锁失败，因为分布式场景下失败是很正常的情况，所以 32 次并不是一个很夸张的值。

1. delayFunc

复制代码

字段是每次失败后重试的间隔时间。其他字段我就不一一讲解了，绝大多数我们都用不到。
根据代码我们很容易想到这几个字段是通过选项模式来设置的。

• 1. WithExpiry(time.Duration)

  复制代码
  ：设置锁的自动过期时间（建议大于业务执行时间）。
  
• 1. WithTries(int)

  复制代码
  ：设置最大重试次数。
  
• 1. WithRetryDelay(time.Duration)

  复制代码
  ：设置重试间隔。
  

使用示例：

1. mutex := rs.NewMutex("test-redsync",
   
2.     redsync.WithExpiry(30*time.Second),
   
3.     redsync.WithTries(3),
   
4.     redsync.WithRetryDelay(500*time.Millisecond),
   
5. )

复制代码

看门狗

我们现在知道使用分布式锁一定要设置一个过期时间了，但是这会带来另外一个问题：如果我们的业务代码还没执行完，锁就过期自动释放了，那么此时另外一个进程成功拿到这把锁，也来访问竞态资源，那分布式锁不就失去意义了吗？
这就引出了使用分布式锁的另一个重要问题，锁自动续期。我举一个代码示例，你就懂了：

1. package main
   
2. 
   
3. import (
   
4.         "context"
   
5.         "log/slog"
   
6.         "time"
   
7. 
   
8.         "github.com/go-redsync/redsync/v4"                  // 引入 redsync 库，用于实现基于 Redis 的分布式锁
   
9.         "github.com/go-redsync/redsync/v4/redis/goredis/v9" // 引入 redsync 的 goredis 连接池
   
10.         goredislib "github.com/redis/go-redis/v9"           // 引入 go-redis 库，用于与 Redis 服务器通信
    
11. )
    
12. 
    
13. func main() {
    
14.         // 创建一个 Redis 客户端
    
15.         client := goredislib.NewClient(&goredislib.Options{
    
16.                 Addr:     "localhost:36379", // Redis 服务器地址
    
17.                 Password: "nightwatch",
    
18.         })
    
19. 
    
20.         // 使用 go-redis 客户端创建一个 redsync 连接池
    
21.         pool := goredis.NewPool(client)
    
22. 
    
23.         // 创建一个 redsync 实例，用于管理分布式锁
    
24.         rs := redsync.New(pool)
    
25. 
    
26.         // 创建一个名为 "test-redsync" 的互斥锁（Mutex）
    
27.         mutex := rs.NewMutex("test-redsync", redsync.WithExpiry(5*time.Second))
    
28. 
    
29.         // 创建一个上下文（context），一般用于控制锁的超时和取消
    
30.         ctx, cancel := context.WithCancel(context.Background())
    
31.         defer cancel()
    
32. 
    
33.         // 获取锁，如果获取失败（例如锁已被其他进程持有），会返回错误
    
34.         if err := mutex.LockContext(ctx); err != nil {
    
35.                 panic(err) // 如果获取锁失败，程序会 panic
    
36.         }
    
37. 
    
38.         // 看门狗，实现锁自动续约
    
39.         stopCh := make(chan struct{})
    
40.         ticker := time.NewTicker(2 * time.Second) // 每隔 2s 续约一次
    
41.         defer ticker.Stop()
    
42.         go func() {
    
43.                 for {
    
44.                         select {
    
45.                         case <-ticker.C:
    
46.                                 // 续约，延长锁的过期时间
    
47.                                 if ok, err := mutex.ExtendContext(ctx); !ok || err != nil {
    
48.                                         slog.Error("Failed to extend mutex", "err", err, "status", ok)
    
49.                                 } else {
    
50.                                         slog.Info("Successfully extend mutex")
    
51.                                 }
    
52.                         case <-stopCh:
    
53.                                 slog.Info("Exiting mutex watchdog")
    
54.                                 return
    
55.                         }
    
56.                 }
    
57.         }()
    
58. 
    
59.         // 执行业务逻辑
    
60.         time.Sleep(6 * time.Second)
    
61. 
    
62.         // 通知看门狗停止自动续期
    
63.         stopCh <- struct{}{}
    
64. 
    
65.         // 释放锁，如果释放失败（例如锁已过期或不属于当前进程），会返回错误
    
66.         if _, err := mutex.UnlockContext(ctx); err != nil {
    
67.                 panic(err) // 如果释放锁失败，程序会 panic
    
68.         }
    
69. }

复制代码

这个示例延续了前文中的示例代码，你需要重点关注的是如下这部分逻辑：

1. // 看门狗，实现锁自动续约
   
2. stopCh := make(chan struct{})
   
3. ticker := time.NewTicker(2 * time.Second) // 每隔 2s 续约一次
   
4. defer ticker.Stop()
   
5. go func() {
   
6.     for {
   
7.         select {
   
8.         case <-ticker.C:
   
9.             // 续约，延长锁的过期时间
   
10.             if ok, err := mutex.ExtendContext(ctx); !ok || err != nil {
    
11.                 slog.Error("Failed to extend mutex", "err", err, "status", ok)
    
12.             } else {
    
13.                 slog.Info("Successfully extend mutex")
    
14.             }
    
15.         case <-stopCh:
    
16.             slog.Info("Exiting mutex watchdog")
    
17.             return
    
18.         }
    
19.     }
    
20. }()

复制代码

1. redsync

复制代码

提供了

1. mutex.ExtendContext(ctx)

复制代码

方法可以延长锁的过期时间。假设我们申请的分布式锁过期时间是 5 秒，而业务代码执行时间是未知的，那么我们在拿到锁以后，可以单独开启一个 goroutine 来定时延长锁的过期时间，当业务代码执行完成以后，主 goroutine 通过

1. stopCh <- struct{}{}

复制代码

向子 goroutine 发送停止信号，那么子 goroutine 中的

1. <-stopCh

复制代码

case 就会收到通知，子 goroutine 便会退出，也就停止了锁自动续期。
通过为分布式锁设置过期时间，再配合子 goroutine 自动续期的功能，我们就能保证，持有锁的进程挂掉时不会影响其他进程获取锁，并且还能实现业务执行完成后才释放锁。而这个实现分布式锁自动续期的程序，我们通常把它叫做“看门狗”。
我再额外啰嗦一句，关于分布式锁的续期时常和间隔周期的问题，一般来说，续期的时间可以设置为等于过期时间，即锁的过期时间设为 5 秒，那么每次也只续期 5 秒，

1. redsync

复制代码

内部也是这么做的，至于间隔多久续期一次，这个时间肯定是要小于过期时间 5 秒的，通常设为锁过期时间的 1/3 或 1/2 都可以。

redsync 原理

我上面讲解的

1. redsync

复制代码

用法基本上能覆盖业务开发中的大部分场景了，对于

1. redsync

复制代码

更多的功能我就不过多介绍了，有了现有的知识，你遇到了问题也可以自己查阅文档学习。 下面我想讲点更有价值的东西，我们自己来实现一个微型的 Redis 分布式锁，以此来加深你对

1. redsync

复制代码

的理解。

如何实现一个 Redis 分布式锁

要基于 Redis 实现一个最小化的分布式锁，我们可以定义一个结构体

1. MiniRedisMutex

复制代码

作为锁对象：

1. type MiniRedisMutex struct {
   
2.         name   string        // 会作为分布式锁在 Redis 中的 key
   
3.         expiry time.Duration // 锁过期时间
   
4.         conn   redis.Cmdable // Redis Client
   
5. }

复制代码

它仅包含必要的字段，

1. name

复制代码

是锁的名称，

1. expiry

复制代码

是分布式锁必须要有的过期时间，

1. conn

复制代码

用来存储 Redis 客户端连接。
我们可以定义一个构造函数

1. NewMutex

复制代码

来创建分布式锁对象：

1. func NewMutex(name string, expiry time.Duration, conn redis.Cmdable) *MiniRedisMutex {
   
2.         return &MiniRedisMutex{name, expiry, conn}
   
3. }

复制代码

接下来就要实现加锁和解锁这两个功能。
加锁方法

1. Lock

复制代码

实现如下：

1. func (m *MiniRedisMutex) Lock(ctx context.Context, value string) (bool, error) {
   
2.         reply, err := m.conn.SetNX(ctx, m.name, value, m.expiry).Result()
   
3.         if err != nil {
   
4.                 return false, err
   
5.         }
   
6.         return reply, nil
   
7. }

复制代码

1. Lock

复制代码

方法接收两个参数，

1. ctx

复制代码

用来控制取消，

1. value

复制代码

则会作为锁的值。

1. Lock

复制代码

方法内部逻辑非常简单，直接调用 Redis 的

1. SetNX

复制代码

命令来排他的设置一个键值对，锁名称

1. name

复制代码

作为 Redis 的

1. key

复制代码

，锁的值

1. value

复制代码

作为 Redis 的

1. value

复制代码

，并指定过期时间为

1. expiry

复制代码

，这就是分布式锁的加锁原理。
这里有两个关键点需要你注意：

• 使用
  1. SetNX

  复制代码
  命令：这里之所以使用
  1. SetNX

  复制代码
  命令而不是普通的
  1. Set

  复制代码
  命令，是因为加锁操作需要排他性。我们知道，
  1. SetNX

  复制代码
  命令的全称是
  1. SET if Not eXists

  复制代码
  ，即通过
  1. SetNX

  复制代码
  命令设置键值对时，如果
  1. key

  复制代码
  不存在，设置其
  1. value

  复制代码
  ，若
  1. key

  复制代码
  已存在，则不执行任何操作。这刚好符合互斥性，是实现分布式互斥锁的关键所在。
  
• 1. value

  复制代码
  唯一性：虽然
  1. SetNX

  复制代码
  命令能够实现互斥，但是 Redis 的
  1. value

  复制代码
  还是要保证唯一性。这一点我们接着往下看你就明白了。
  

释放锁方法

1. Unlock

复制代码

实现如下：

1. // 释放锁的 lua 脚本，保证并发安全
   
2. var deleteScript = `
   
3.         local val = redis.call("GET", KEYS[1])
   
4.         if val == ARGV[1] then
   
5.                 return redis.call("DEL", KEYS[1])
   
6.         elseif val == false then
   
7.                 return -1
   
8.         else
   
9.                 return 0
   
10.         end
    
11. `
    
12. 
    
13. // Unlock 释放锁
    
14. func (m *MiniRedisMutex) Unlock(ctx context.Context, value string) (bool, error) {
    
15.         // 执行 lua 脚本，Redis 会保证其并发安全
    
16.         status, err := m.conn.Eval(ctx, deleteScript, []string{m.name}, value).Result()
    
17.         if err != nil {
    
18.                 return false, err
    
19.         }
    
20.         if status == int64(-1) {
    
21.                 return false, ErrLockAlreadyExpired
    
22.         }
    
23.         return status != int64(0), nil
    
24. }

复制代码

在释放锁的逻辑中，我们不是简单的将指定的 Redis 键值对删除即可，而是调用

1. m.conn.Eval

复制代码

方法执行了一段 lua 脚本的方式来释放锁。
在这段 lua 脚本中，我们先是从 Redis 中获取指定

1. key

复制代码

为

1. m.name

复制代码

的键值对，然后判断其

1. value

复制代码

是否等于

1. Unlock

复制代码

方法传入的

1. value

复制代码

参数值，如果相等，则从 Redis 中删除指定的键值对，表示释放锁，否则什么也不做。
之所以要对

1. value

复制代码

进行判断，是因为我们要保证这把锁是当前进程所持有的锁，而不是其他进程持有的锁。那么以什么为依据来说明这把锁是当前进程持有的呢？这就是我们要保证

1. value

复制代码

唯一的原因，每个进程在加锁的时候，需要生成一个随机的

1. value

复制代码

作为自己的锁的标识，那么释放时，就可以通过这个

1. value

复制代码

来判断是否是自己持有的锁。而这样做的目的，是为了避免一个进程抢到锁后，还在执行业务逻辑时，锁被另外一个进程给释放了。
遗憾的是，这段释放锁的逻辑，Redis 没有提供像

1. SetNX

复制代码

一样的快捷命令，所以我们只能将其放在 lua 脚本中执行，才能保证并发安全。
至此，一个微型的 Redis 分布式锁的核心功能咱们就讲解完成了。
以下是

1. MiniRedisMutex

复制代码

分布式锁完整的代码实现：

1. package miniredislockimport (        "context"        "errors"        "time"        "github.com/redis/go-redis/v9")var ErrLockAlreadyExpired = errors.New("miniredislock: failed to unlock, lock was already expired")// MiniRedisMutex 一个微型的 Redis 分布式锁type MiniRedisMutex struct {
   
2.         name   string        // 会作为分布式锁在 Redis 中的 key
   
3.         expiry time.Duration // 锁过期时间
   
4.         conn   redis.Cmdable // Redis Client
   
5. }// NewMutex 创建 Redis 分布式锁func NewMutex(name string, expiry time.Duration, conn redis.Cmdable) *MiniRedisMutex {
   
6.         return &MiniRedisMutex{name, expiry, conn}
   
7. }// Lock 加锁func (m *MiniRedisMutex) Lock(ctx context.Context, value string) (bool, error) {
   
8.         reply, err := m.conn.SetNX(ctx, m.name, value, m.expiry).Result()
   
9.         if err != nil {
   
10.                 return false, err
    
11.         }
    
12.         return reply, nil
    
13. }// 释放锁的 lua 脚本，保证并发安全
    
14. var deleteScript = `
    
15.         local val = redis.call("GET", KEYS[1])
    
16.         if val == ARGV[1] then
    
17.                 return redis.call("DEL", KEYS[1])
    
18.         elseif val == false then
    
19.                 return -1
    
20.         else
    
21.                 return 0
    
22.         end
    
23. `
    
24. 
    
25. // Unlock 释放锁
    
26. func (m *MiniRedisMutex) Unlock(ctx context.Context, value string) (bool, error) {
    
27.         // 执行 lua 脚本，Redis 会保证其并发安全
    
28.         status, err := m.conn.Eval(ctx, deleteScript, []string{m.name}, value).Result()
    
29.         if err != nil {
    
30.                 return false, err
    
31.         }
    
32.         if status == int64(-1) {
    
33.                 return false, ErrLockAlreadyExpired
    
34.         }
    
35.         return status != int64(0), nil
    
36. }

复制代码

其实，这段代码的主要逻辑，都是我从

1. redsync

复制代码

源码中提取出来。所以

1. redsync

复制代码

其实也是这样实现的，只不过它内部增加了很多可靠性和边缘场景等逻辑代码，最核心的加锁和解锁逻辑是一样的。

微型分布式锁使用

下面我们来写一个示例程序，演示下如何使用这个微型的分布式锁：

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. 
   
7.         goredislib "github.com/redis/go-redis/v9"
   
8.         "golang.org/x/net/context"
   
9. 
   
10.         "github.com/jianghushinian/blog-go-example/redsync/miniredislock"
    
11. )
    
12. 
    
13. func main() {
    
14.         // 创建一个 Redis 客户端
    
15.         client := goredislib.NewClient(&goredislib.Options{
    
16.                 Addr:     "localhost:36379", // Redis 服务器地址
    
17.                 Password: "nightwatch",
    
18.         })
    
19.         defer client.Close()
    
20. 
    
21.         // 创建一个名为 "test-miniredislock" 的互斥锁
    
22.         mutex := miniredislock.NewMutex("test-miniredislock", 5*time.Second, client)
    
23. 
    
24.         ctx := context.Background()
    
25.         // 互斥锁的值应该是一个随机值
    
26.         value := "random-string"
    
27. 
    
28.         // 获取锁
    
29.         _, err := mutex.Lock(ctx, value)
    
30.         if err != nil {
    
31.                 panic(err)
    
32.         }
    
33. 
    
34.         // 执行业务逻辑
    
35.         fmt.Println("do something...")
    
36.         time.Sleep(3 * time.Second)
    
37. 
    
38.         // 释放自己持有的锁
    
39.         _, err = mutex.Unlock(ctx, value)
    
40.         if err != nil {
    
41.                 panic(err)
    
42.         }
    
43. }

复制代码

这个示例的具体逻辑我就不逐行讲解了，相信你一看便懂。也希望你能够自己在本机上跑起来这段代码，真正用一下分布式锁，以此加深理解。
最后我再留一个作业，你可以尝试一下实现锁的续期方法

1. Extend

复制代码

。

总结

分布式锁可以确保分布式系统中并发安全的访问竞态资源，

1. redsync

复制代码

作为 Go 中最流行的 Redis 分布式锁方案，非常值得我们学习和使用。

1. redsync

复制代码

的用法非常简单，加锁和解锁操作与

1. sync.Mutex

复制代码

也非常类似，没有太多的学习成本。不过，为了避免持有锁的进程挂掉时，其他进程还有机会获取锁，我们需要实现看门狗的功能。
到此这篇关于Go语言如何使用分布式锁解决并发问题的文章就介绍到这了,更多相关Go分布式锁解决并发内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！