Golang中实现分布式锁的可靠方案-Golang-PHP中文网

Golang中实现分布式锁的可靠方案

穿越時空

发布： 2025-06-23 14:05:01

原创

388人浏览过

在golang中实现分布式锁需考虑安全性、可靠性与性能，主要方案包括：1. 基于redis的分布式锁，使用setnx命令和过期时间实现，优点是实现简单、性能高，缺点是可能存在锁过期或续租机制复杂；2. 基于zookeeper的分布式锁，利用临时顺序节点实现，可靠性高但性能较低且实现较复杂；3. 基于etcd的分布式锁，采用lease和watch机制，性能较高且易于部署，但实现也较复杂。选择方案时应根据业务需求权衡性能与可靠性，redis适合高性能场景，zookeeper和etcd适合高可靠性场景。续租机制用于延长锁的有效期，防止任务执行期间锁被释放；避免误删除可通过设置唯一value并在释放锁时进行校验实现，确保仅删除自身持有的锁。

Golang中实现分布式锁的可靠方案

在Golang中实现分布式锁，需要考虑锁的安全性、可靠性和性能。简单来说，就是确保在分布式环境下，只有一个客户端能获得锁，并且即使发生故障，锁也能被正确释放。

解决方案

实现分布式锁，通常有以下几种方案，各有优劣：

基于Redis的分布式锁： 利用Redis的SETNX (SET if Not Exists) 命令和过期时间来实现。SETNX保证只有一个客户端能成功设置锁，过期时间防止死锁。

立即学习“go语言免费学习笔记（深入）”；

优点： 实现简单，性能高。
缺点： 可能存在锁过期时间不足导致锁被提前释放，或锁续租机制复杂。需要考虑Redlock算法来提高可靠性，但Redlock本身也存在争议。

import (
    "github.com/go-redis/redis/v8"
    "context"
    "time"
)

func acquireLock(ctx context.Context, rdb *redis.Client, lockKey string, lockValue string, expireTime time.Duration) (bool, error) {
    ok, err := rdb.SetNX(ctx, lockKey, lockValue, expireTime).Result()
    if err != nil {
        return false, err
    }
    return ok, nil
}

func releaseLock(ctx context.Context, rdb *redis.Client, lockKey string, lockValue string) error {
    // 使用Lua脚本保证原子性
    script := `
        if redis.call("GET", KEYS[1]) == ARGV[1] then
            return redis.call("DEL", KEYS[1])
        else
            return 0
        end
    `
    result, err := rdb.Eval(ctx, script, []string{lockKey}, lockValue).Result()
    if err != nil {
        return err
    }
    if result == int64(1) {
        return nil
    }
    return nil // 锁已被其他客户端释放
}

登录后复制

基于ZooKeeper的分布式锁： 利用ZooKeeper的临时顺序节点来实现。客户端创建一个临时顺序节点，序号最小的节点获得锁。当客户端崩溃时，临时节点自动删除，释放锁。

优点： 可靠性高，锁的释放由ZooKeeper保证。
缺点： 性能相对较低，实现复杂。需要引入ZooKeeper客户端库。

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

func acquireLockZk(conn *zk.Conn, lockPath string, data []byte) (string, error) {
    // 创建临时顺序节点
    path, err := conn.Create(lockPath+"/", data, 0, zk.WorldACL(zk.PermAll))
    if err != nil {
        return "", err
    }

    // 获取所有子节点
    children, _, err := conn.Children(lockPath)
    if err != nil {
        return "", err
    }

    sort.Strings(children)

    // 判断当前节点是否是最小的节点
    if path == lockPath+"/"+children[0] {
        return path, nil // 获得锁
    }

    // 监听前一个节点
    index, _ := strconv.Atoi(path[len(lockPath)+1:])
    prevIndex := index - 1
    if prevIndex < 0 {
        prevIndex = 0
    }
    prevNode := lockPath + "/" + children[prevIndex]

    _, _, ch, err := conn.GetW(prevNode)
    if err != nil {
        return "", err
    }

    <-ch // 阻塞等待前一个节点释放

    return acquireLockZk(conn, lockPath, data) // 递归尝试获取锁
}

func releaseLockZk(conn *zk.Conn, lockPath string) error {
    err := conn.Delete(lockPath, -1)
    return err
}

登录后复制

基于Etcd的分布式锁： 类似于ZooKeeper，利用Etcd的lease机制和watch机制来实现。

优点： 相比ZooKeeper，Etcd性能更高，更易于部署。
缺点： 实现复杂。需要引入Etcd客户端库。

import (
    "context"
    "time"
    "github.com/coreos/etcd/clientv3"
)

func acquireLockEtcd(cli *clientv3.Client, lockKey string, leaseTTL int64) (clientv3.LeaseID, error) {
    // 创建 lease
    resp, err := cli.Grant(context.TODO(), leaseTTL)
    if err != nil {
        return clientv3.LeaseID(0), err
    }

    // 尝试获取锁
    _, err = cli.Put(context.TODO(), lockKey, "locked", clientv3.WithLease(resp.ID))
    if err != nil {
        return clientv3.LeaseID(0), err
    }

    // 续租，保持锁
    keepAliveChan, err := cli.KeepAlive(context.TODO(), resp.ID)
    if err != nil {
        return clientv3.LeaseID(0), err
    }

    go func() {
        for range keepAliveChan {
        }
    }()

    return resp.ID, nil
}

func releaseLockEtcd(cli *clientv3.Client, lockKey string, leaseID clientv3.LeaseID) error {
    _, err := cli.Revoke(context.TODO(), leaseID)
    return err
}

登录后复制