分布式锁，作为现代后端架构中维持资源一致性和避免混乱的关键基石，在电商抢购、任务调度和分布式事务等场景中扮演“隐形英雄”的角色。当多个节点需要协同访问某一资源时，分布式锁正如交通信号灯，维持秩序、保证一致。

本文面向已具备 Go 语言基础、熟练掌握 goroutine 和 sync.Mutex，但对分布式系统仍感迷惑的开发者。本文将由浅入深，带领大家了解分布式锁的原理，并用 Go 实现高效可靠的分布式锁。

分布式锁基本原理（以及为什么选择 Go？）

先来，了解下分布式锁的基本原理及为什么要选择 Go 语言来实现分布式锁。

分布式锁的核心诉求

分布式锁须处理以下三大问题：

• 互斥性：同一时刻仅允许一个客户端持有锁，防止数据竞争和错乱；
• 可靠性：锁不会无缘无故丢失，即使面临节点宕机或网络故障；
• 性能：高并发场景下依然能快速争抢和释放锁。

这些特性对于防止电商超卖、保证唯一任务执行等至关重要。

为什么选择 Go？

那么，为什么选择 Go 来做这个呢？原因如下：

• 并发强劲：Go 的 goroutine 轻量高效，适合模拟海量的并发锁争抢；channel 让重试和通信逻辑尤为简洁；
• 优秀生态：诸如 go-redis、go-zookeeper、etcd/clientv3 等主流库均有活跃支持，开箱即用，适合生产环境；
• 简洁高效：Go 语法简洁，开发者可以极少的代码实现高性能锁逻辑，维护成本低。

---

与其他语言对比：

语言	并发体验	使用门槛	复杂度
Go	并发友好、简单	无内置事务，但外部库强	简单
Java	成熟稳健	框架和设置较繁琐	中等
Python	敏捷开发	受 GIL 限制，性能一般	复杂

结论：Go 是搭建分布式锁的理想选择。接下来，我们将进入实际编码阶段。

动手实践：用 Go 实现分布式锁

我们将分别基于 Redis、ZooKeeper 和 etcd 进行分布式锁实现展示。每种方案各有优劣，均有贴合实际生产环境的 Go 代码可用。

基于 Redis 的分布式锁

原理概述

Redis 通常借助 SETNX（不存在则设置）命令及过期时间（TTL）实现锁，避免死锁。再通过 Lua 脚本确保只有锁拥有者可以解锁，防范误删。

Go 代码示例

package main

import (
    "context"
    "fmt"
    "time"

    "github.com/go-redis/redis/v8"
)

var ctx = context.Background()

func acquireLock(client *redis.Client, key, value string, ttl time.Duration) (bool, error) {
    ok, err := client.SetNX(ctx, key, value, ttl).Result()
    return ok, err
}

func releaseLock(client *redis.Client, key, value string) error {
    script := `if redis.call("GET", KEYS[1]) == ARGV[1] then return redis.call("DEL", KEYS[1]) end`
    _, err := client.Eval(ctx, script, []string{key}, value).Result()
    return err
}

func main() {
    client := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    defer client.Close()

    key := "pizza_lock"
    value := "client-123" // Unique ID
    ttl := 5 * time.Second

    if ok, err := acquireLock(client, key, value, ttl); ok && err == nil {
        fmt.Println("Got the lock—eating pizza!")
        time.Sleep(2 * time.Second) // Nom nom
        releaseLock(client, key, value)
        fmt.Println("Lock’s free!")
    } else {
        fmt.Println("Missed it:", err)
    }
}

适用场景：追求高性能、允许一定一致性弹性的场景（如电商秒杀）。

基于 ZooKeeper 的分布式锁

原理概述

通过临时有序节点机制进行排队式锁竞争，保障严格一致性。每个客户端创建节点后，检查自己编号是否最小，从而决定是否获得锁。

Go 代码示例

package main

import (
    "fmt"
    "sort"
    "time"

    "github.com/samuel/go-zookeeper/zk"
)

func acquireLock(conn *zk.Conn, path string) (string, error) {
    node, err := conn.Create(path+"/lock-", nil, zk.FlagEphemeral|zk.FlagSequence)
    if err != nil {
        return "", err
    }
    for {
        kids, _, err := conn.Children(path)
        if err != nil {
            return "", err
        }
        sort.Strings(kids)
        if path+"/"+kids[0] == node {
            return node, nil // You’re up!
        }
        prev := kids[0] // Watch the guy in front
        for i, k := range kids {
            if path+"/"+k == node {
                prev = kids[i-1]
                break
            }
        }
        _, _, ch, _ := conn.Get(path + "/" + prev)
        <-ch // Wait for them to leave
    }
}

func main() {
    conn, _, err := zk.Connect([]string{"localhost:2181"}, 5*time.Second)
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    path := "/locks"
    if node, err := acquireLock(conn, path); err == nil {
        fmt.Println("Locked:", node)
        time.Sleep(2 * time.Second)
        conn.Delete(node, -1)
        fmt.Println("Unlocked!")
    } else {
        fmt.Println("Oops:", err)
    }
}

适用场景：强一致性诉求，如金融、关键调度等。

基于 etcd 的分布式锁

原理概述

etcd 采用租约（lease）与键竞争机制，客户端只要持有租约且键未被他人占用，即可获取锁。

Go 代码示例

package main

import (
    "context"
    "fmt"
    "time"

    "go.etcd.io/etcd/client/v3"
)

func acquireLock(cli *clientv3.Client, key string, ttl int64) (*clientv3.LeaseGrantResponse, error) {
    lease, err := cli.Grant(context.Background(), ttl)
    if err != nil {
        return nil, err
    }
    txn := cli.Txn(context.Background()).
        If(clientv3.Compare(clientv3.CreateRevision(key), "=", 0)).
        Then(clientv3.OpPut(key, "locked", clientv3.WithLease(lease.ID)))
    resp, err := txn.Commit()
    if err != nil || !resp.Succeeded {
        return nil, fmt.Errorf("lock failed")
    }
    return lease, nil
}

func main() {
    cli, _ := clientv3.New(clientv3.Config{
        Endpoints:   []string{"localhost:2379"},
        DialTimeout: 5 * time.Second,
    })
    defer cli.Close()

    key := "/desk_lock"
    if lease, err := acquireLock(cli, key, 10); err == nil {
        fmt.Println("Desk’s mine!")
        time.Sleep(2 * time.Second)
        cli.Revoke(context.Background(), lease.ID)
        fmt.Println("Desk’s free!")
    } else {
        fmt.Println("No desk:", err)
    }
}

适用场景：云原生、Kubernetes 周边应用，兼顾性能与一致性。

三者比较

工具	特点	优劣权衡	典型场景
Redis	超高并发、简单部署	一致性略弱	秒杀系统
ZooKeeper	强一致性、公平排队	部署和维护复杂	关键资源调度
etcd	Go 原生、云原生契合	高压下有延迟风险	K8s 周边

工程经验与最佳实践

管代码已就绪，分布式锁落地仍暗藏诸多挑战。它们犹如接力赛的棒子：一旦脱手，系统便可能全面失控。本节归纳关键最佳实践与常见陷阱，助你把锁打造得坚不可摧。

推荐实践

• 细粒度锁定：按资源细分锁，而非一把总锁，减少争用。如按商品 ID 建锁。

func lockItem(client *redis.Client, itemID string, ttl time.Duration) (bool, error) {
    key := fmt.Sprintf("lock:item:%s", itemID) // Per-item lock
    return acquireLock(client, key, "client-123", ttl)
}

• 控制超时与重试：利用 context 和指数退避策略优雅处理网络及任务慢节点。

func tryLock(client *redis.Client, key string, ttl time.Duration, retries int) (bool, error) {
    ctx, cancel := context.WithTimeout(context.Background(), ttl)
    defer cancel()
    backoff := 100 * time.Millisecond
    for i := 0; i < retries; i++ {
        if ok, err := acquireLock(client, key, "client-123", ttl); ok && err == nil {
            return true, nil
        }
        time.Sleep(backoff)
        backoff *= 2
    }
    return false, fmt.Errorf("gave up after %d tries", retries)
}

• 监控与指标：追踪锁请求/释放延时，发现瓶颈，建议用 Prometheus 等埋点。

func lockWithMetrics(client *redis.Client, key string, ttl time.Duration) (bool, error) {
    start := time.Now()
    ok, err := acquireLock(client, key, "client-123", ttl)
    fmt.Printf("Lock %s: success=%v, took=%v\n", key, ok, time.Since(start))
    return ok, err
}

常见陷阱与避坑指南

• 锁误删误释放：锁失效。 这时候可以通过唯一身份标识和 Lua 脚本限制（见 Redis 示例），保证只由持有者释放。问题场景如：客户 A 的锁过期，B 抢走了它，然后 A 不小心将其删除；
• ZooKeeper 网络波动时锁丢失：增加断线重连和状态二次确认机制。问题场景如：在一个支付系统中，网络抖动导致 ZooKeeper 连接中断，锁被杀掉，订单被重复；

func lockWithRetry(conn *zk.Conn, path string) (string, error) {
    for {
        node, err := acquireLock(conn, path)
        if err == nil && conn.State() == zk.StateConnected {
            return node, nil
        }
        time.Sleep(time.Second)
        conn, _, _ = zk.Connect([]string{"localhost:2181"}, 5*time.Second)
    }
}

• etcd 高并发下租约阻塞：提前分配租约，缓存复用。问题场景如：在重负载下，etcd 的租约请求堆积，导致锁获取速度极慢。

type LeasePool struct {
    leases []clientv3.LeaseID
    sync.Mutex
}

func (p *LeasePool) Get(cli *clientv3.Client, ttl int64) (clientv3.LeaseID, error) {
    p.Lock()
    defer p.Unlock()
    if len(p.leases) > 0 {
        id := p.leases[0]
        p.leases = p.leases[1:]
        return id, nil
    }
    lease, err := cli.Grant(context.Background(), ttl)
    return lease.ID, err
}

典型应用场景示例

是时候让我们的锁发挥作用了！我们将处理两个经典案例：电子商务闪购和分布式任务调度器。

电商秒杀防超卖

结合 Redis 锁按商品抢购，全并发环境下确保库存不会被重复扣减。代码示例如下：

package main

import (
    "fmt"
    "time"

    "github.com/go-redis/redis/v8"
)

type Shop struct {
    client *redis.Client
}

func (s *Shop) Buy(itemID, userID string) (bool, error) {
    lockKey := fmt.Sprintf("lock:%s", itemID)
    uuid := userID + "-" + fmt.Sprint(time.Now().UnixNano())
    ttl := 5 * time.Second

    if ok, err := acquireLock(s.client, lockKey, uuid, ttl); !ok || err != nil {
        return false, err
    }
    defer releaseLock(s.client, lockKey, uuid)

    stockKey := fmt.Sprintf("stock:%s", itemID)
    stock, _ := s.client.Get(context.Background(), stockKey).Int()
    if stock <= 0 {
        return false, nil
    }
    s.client.Decr(context.Background(), stockKey)
    return true, nil
}

func main() {
    client := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    shop := &Shop{client}
    client.Set(context.Background(), "stock:item1", 5, 0) // 5 units
    for i := 0; i < 10; i++ {
        go func(id int) {
            if ok, _ := shop.Buy("item1", fmt.Sprintf("user%d", id)); ok {
                fmt.Printf("User %d scored!\n", id)
            } else {
                fmt.Printf("User %d out of luck\n", id)
            }
        }(i)
    }
    time.Sleep(2 * time.Second)
}

分布式任务调度唯一执行

基于 etcd，为定时任务（如日志清理）提供“全局唯一运行”保障，防止重复执行。代码示例如下：

package main

import (
    "fmt"
    "time"

    "go.etcd.io/etcd/client/v3"
)

type Scheduler struct {
    client *clientv3.Client
}

func (s *Scheduler) Run(taskID string) error {
    key := fmt.Sprintf("/lock/%s", taskID)
    lease, err := acquireLock(s.client, key, 10)
    if err != nil {
        return err
    }
    defer s.client.Revoke(context.Background(), lease.ID)

    fmt.Printf("Running %s\n", taskID)
    time.Sleep(2 * time.Second) // Fake work
    fmt.Printf("%s done\n", taskID)
    return nil
}

func main() {
    cli, _ := clientv3.New(clientv3.Config{Endpoints: []string{"localhost:2379"}})
    defer cli.Close()
    s := &Scheduler{cli}
    for i := 0; i < 3; i++ {
        go func() {
            s.Run("cleanup")
        }()
    }
    time.Sleep(5 * time.Second)
}

总结与展望

回顾全文，结合工程经验，Go 在实现分布式锁时具备：简洁、高效、并发优势，辅以良好生态（go-redis、etcd 等），可适配多样的业务需求。

实际实践中要关注锁粒度、超时机制、监控和失败处理。建议从 Redis 起步，逐步深入至 ZooKeeper/etcd 等高级方案。

随着云原生和 Go 生态演进，分布式锁将更易用、扩展性更强。愿本文能助你驾驭分布式锁复杂性，为高并发业务保驾护航。

最后提示：锁是工具而非万能法宝。选择合适场景和实现路径，让系统既快又稳。

往期文章推荐

• 在 Go 中如何使用分布式锁解决并发问题？
• 如何基于 Go 语言设计一个简洁优雅的分布式任务系统

欢迎关注我：

• 知识星球：云原生 AI 实战营，10+ 高质量体系课（ Go、云原生、AI Infra）、15+ 实战项目，助你提高技术天花板，入大厂、拿高薪；
• 微信GZH：令飞编程，分享 Go、云原生、AI Infra 相关技术。回复「资料」免费下载 Go、云原生、AI 等学习资料；
• 哔哩哔哩：令飞编程 ，分享技术、职场、面经等，并有免费直播课「云原生AI高新就业课」，大厂级项目实战到大厂面试通关。