go语言实现分布式互斥锁和红锁(附完整源码）

一、分布式互斥锁（单实例Redis）

// mutex.go
package main

import (
    "context"
    "github.com/redis/go-redis/v9"
    "time"
    "fmt"
    "github.com/google/uuid"
)

type RedisMutex struct {
    client *redis.Client
    key    string
    value  string
    ttl    time.Duration
}

func NewRedisMutex(client *redis.Client, key string, ttl time.Duration) *RedisMutex {
    return &RedisMutex{
        client: client,
        key:    key,
        value:  uuid.NewString(),
        ttl:    ttl,
    }
}

// TryLock 尝试获取锁
func (m *RedisMutex) TryLock(ctx context.Context) (bool, error) {
    ok, err := m.client.SetNX(ctx, m.key, m.value, m.ttl).Result()
    return ok, err
}

// Unlock 释放锁
func (m *RedisMutex) Unlock(ctx context.Context) (bool, error) {
    // 只释放自己加的锁，防止误删
    luaScript := `
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end
`
    res, err := m.client.Eval(ctx, luaScript, []string{m.key}, m.value).Result()
    if err != nil {
        return false, err
    }
    return res.(int64) != 0, nil
}

// 示例
func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    mutex := NewRedisMutex(client, "mylock", 10*time.Second)

    ok, err := mutex.TryLock(ctx)
    if err != nil {
        panic(err)
    }
    if !ok {
        fmt.Println("获取锁失败")
        return
    }
    fmt.Println("获得锁，执行业务逻辑")
    // ...业务逻辑...

    unlocked, err := mutex.Unlock(ctx)
    if err != nil {
        panic(err)
    }
    if unlocked {
        fmt.Println("释放锁成功")
    } else {
        fmt.Println("释放锁失败")
    }
}

二、RedLock（红锁）分布式锁实现

RedLock算法需要多个独立Redis实例，大多数实例都加锁成功才算加锁成功。

// redlock.go
package main

import (
    "context"
    "github.com/redis/go-redis/v9"
    "time"
    "fmt"
    "github.com/google/uuid"
)

type RedisInstance struct {
    client *redis.Client
}

type RedLock struct {
    instances []*RedisInstance
    key       string
    value     string
    ttl       time.Duration
    quorum    int // 至少需要多少个实例加锁成功
}

func NewRedLock(redisAddrs []string, key string, ttl time.Duration) *RedLock {
    instances := make([]*RedisInstance, len(redisAddrs))
    for i, addr := range redisAddrs {
        client := redis.NewClient(&redis.Options{Addr: addr})
        instances[i] = &RedisInstance{client: client}
    }
    return &RedLock{
        instances: instances,
        key:       key,
        value:     uuid.NewString(),
        ttl:       ttl,
        quorum:    len(redisAddrs)/2 + 1,
    }
}

func (rl *RedLock) TryLock(ctx context.Context) (bool, error) {
    success := 0
    start := time.Now()
    for _, inst := range rl.instances {
        ok, err := inst.client.SetNX(ctx, rl.key, rl.value, rl.ttl).Result()
        if err == nil && ok {
            success++
        }
    }
    elapsed := time.Since(start)
    // RedLock要求在有效期内获得锁
    if success >= rl.quorum && elapsed < rl.ttl {
        return true, nil
    }
    // 加锁失败，释放已加的锁
    rl.Unlock(ctx)
    return false, nil
}

func (rl *RedLock) Unlock(ctx context.Context) {
    luaScript := `
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end
`
    for _, inst := range rl.instances {
        inst.client.Eval(ctx, luaScript, []string{rl.key}, rl.value)
    }
}

// 示例
func main() {
    ctx := context.Background()
    // 假设有3个Redis实例
    redisAddrs := []string{"localhost:6379", "localhost:6380", "localhost:6381"}
    lock := NewRedLock(redisAddrs, "myredlock", 10*time.Second)

    ok, err := lock.TryLock(ctx)
    if err != nil {
        panic(err)
    }
    if !ok {
        fmt.Println("RedLock获取锁失败")
        return
    }
    fmt.Println("RedLock获得锁，执行业务逻辑")
    // ...业务逻辑...

    lock.Unlock(ctx)
    fmt.Println("RedLock释放锁")
}

三、依赖

你需要安装如下依赖：

go get github.com/redis/go-redis/v9
go get github.com/google/uuid

四、说明

生产环境建议使用现有成熟的库，如 bsm/redislock 或 go-redsync/redsync。
RedLock理论有争议，建议了解其适用场景。
代码仅为教学演示，未做重试、时钟漂移等细节优化。
该博文为原创文章，未经博主同意不得转载。本文章博客地址：https://cplusplus.blog.csdn.net/article/details/148433612