Jorgen's blog
Jorgen
2026-01-28
目录

分布式锁：原理、实现与实战

# 前言

在单机应用中，我们通常使用线程锁（如Java中的synchronized和ReentrantLock）来保证共享资源的互斥访问。然而，随着系统规模的扩大，单机应用逐渐演变为分布式应用，传统的线程锁已经无法满足跨JVM、跨机器的同步需求。这时，分布式锁应运而生，成为解决分布式环境下资源竞争问题的关键技术。

提示

分布式锁是控制分布式系统之间同步访问共享资源的一种方式，可以用于实现分布式系统中的互斥访问控制。

# 分布式锁的基本概念

# 什么是分布式锁？

分布式锁是一种在分布式环境下实现互斥访问的机制，它可以保证在分布式系统中的多个节点对某个共享资源的访问是互斥的。与单机环境下的线程锁类似，分布式锁也提供了获取锁、释放锁、锁超时等基本功能。

# 分布式锁的应用场景

分布式锁广泛应用于以下场景：

  • 秒杀系统：防止同一商品被超卖
  • 订单系统：防止同一订单被重复处理
  • 分布式任务调度：确保同一任务在同一时间只在一个节点上执行
  • 分布式缓存更新：防止多个节点同时更新缓存导致数据不一致

# 分布式锁的实现方案

目前，分布式锁的实现主要有以下几种方案：

# 1. 基于数据库的实现

# 表结构设计

CREATE TABLE `distributed_lock` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `lock_key` varchar(64) NOT NULL DEFAULT '' COMMENT '锁的key',
  `lock_value` varchar(64) NOT NULL DEFAULT '' COMMENT '锁的value',
  `expire_time` bigint(20) NOT NULL COMMENT '过期时间，单位毫秒',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_lock_key` (`lock_key`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='分布式锁表';
1
2
3
4
5
6
7
8
9
10

# 实现原理

  1. 获取锁：使用INSERT语句插入一条记录，如果唯一索引冲突，则获取锁失败
  2. 释放锁：根据lock_key和lock_value删除记录
  3. 锁续期：定时更新记录，延长锁的过期时间

# 优点

  • 实现简单，无需额外依赖
  • 可靠性高，基于数据库的事务机制

# 缺点

  • 性能瓶颈，依赖数据库
  • 单点故障风险，需要主从同步
  • 锁超时时间难以精确控制

# 2. 基于Redis的实现

# 实现原理

Redis作为一种高性能的内存数据库，提供了多种实现分布式锁的方式：

# 方式一：SETNX + EXPIRE
// 获取锁
String result = jedis.set("lock_key", "lock_value", "NX", "EX", 30);
if ("OK".equals(result)) {
    // 获取锁成功
} else {
    // 获取锁失败
}

// 释放锁
jedis.del("lock_key");
1
2
3
4
5
6
7
8
9
10
# 方式二：RedLock（Redis官方推荐）

RedLock是一种更可靠的分布式锁实现，它使用多个独立的Redis实例来提高锁的可靠性：

// 获取锁
RedisLock redisLock1 = new RedisLock(redis1, "lock_key", 30);
RedisLock redisLock2 = new RedisLock(redis2, "lock_key", 30);
RedisLock redisLock3 = new RedisLock(redis3, "lock_key", 30);

// 尝试在大多数实例上获取锁
if (redisLock1.tryLock() && redisLock2.tryLock() && redisLock3.tryLock()) {
    // 获取锁成功
} else {
    // 获取锁失败
    if (redisLock1.isLocked()) redisLock1.unlock();
    if (redisLock2.isLocked()) redisLock2.unlock();
    if (redisLock3.isLocked()) redisLock3.unlock();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 优点

  • 性能高，基于内存操作
  • 支持丰富的数据结构和操作
  • 可以设置锁的自动过期时间

# 缺点

  • 存在Redis单点故障风险（可通过Redis Cluster或RedLock解决）
  • 需要处理网络分区导致的问题
  • 锁的续期需要额外实现

# 3. 基于ZooKeeper的实现

# 实现原理

ZooKeeper是一种分布式协调服务，其临时节点特性非常适合实现分布式锁：

  1. 创建临时顺序节点：客户端在锁的根节点下创建一个临时顺序节点
  2. 获取所有子节点：客户端获取根节点下的所有子节点，并排序
  3. 判断是否是最小节点：如果自己创建的节点是最小的，则获取锁成功
  4. 监听前一个节点：如果不是最小的，则监听前一个节点的删除事件
  5. 等待锁释放：当监听到前一个节点被删除时，重新执行步骤2-4

# 优点

  • 可靠性高，基于ZooKeeper的强一致性
  • 自动释放锁，基于临时节点特性
  • 支持锁的可重入性

# 缺点

  • 性能相对较低，需要频繁的节点操作和监听
  • 依赖ZooKeeper集群，部署复杂
  • 网络分区可能导致锁获取延迟

# 分布式锁的进阶问题

# 锁的续期问题

在分布式锁的实现中，如果客户端在持有锁期间崩溃或网络断开，可能会导致锁无法释放，造成死锁。为了避免这种情况，通常需要实现锁的自动续期机制：

// 锁续期线程
new Thread(() -> {
    while (isLocked) {
        // 续期锁，延长过期时间
        jedis.expire("lock_key", 30);
        try {
            Thread.sleep(10000); // 每10秒续期一次
        } catch (InterruptedException e) {
            break;
        }
    }
}).start();
1
2
3
4
5
6
7
8
9
10
11
12

# 锁的可重入性问题

锁的可重入性是指同一个线程可以多次获取同一个锁而不会造成死锁。在分布式环境下，实现锁的可重入性需要记录锁的持有者和获取次数：

// 使用Redis Hash结构实现可重入锁
String lockKey = "reentrant_lock";
String lockValue = UUID.randomUUID().toString();
String threadId = Thread.currentThread().getId() + "";

// 获取锁
Long count = jedis.hincrBy(lockKey, lockValue, 1);
if (count == 1) {
    // 第一次获取锁，设置过期时间
    jedis.expire(lockKey, 30);
}

// 释放锁
Long newCount = jedis.hincrBy(lockKey, lockValue, -1);
if (newCount == 0) {
    // 计数归零，删除锁
    jedis.del(lockKey);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 锁的公平性问题

公平锁是指按照请求锁的顺序来分配锁，而非公平锁则允许插队。在分布式锁中，可以通过ZooKeeper的顺序节点特性来实现公平锁：

// 创建顺序节点
String sequentialPath = zk.create("/locks/lock-", 
    new byte[0], 
    ZooDefs.Ids.OPEN_ACL_UNSAFE, 
    CreateMode.EPHEMERAL_SEQUENTIAL);

// 获取所有子节点并排序
List<String> children = zk.getChildren("/locks", false);
Collections.sort(children);

// 判断是否是最小节点
String sequentialNode = sequentialPath.substring("/locks/lock-".length());
if (sequentialNode.equals(children.get(0))) {
    // 获取锁成功
} else {
    // 监听前一个节点
    String previousNodePath = "/locks/" + children.get(Collections.binarySearch(children, sequentialNode) - 1);
    zk.exists(previousNodePath, true);
    
    // 等待锁释放
    synchronized (this) {
        wait();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 主流分布式锁组件对比

实现方案 性能 可靠性 实现复杂度 适用场景
数据库锁 低 高 简单 对性能要求不高，已有数据库环境
Redis锁 高 中 中等 高性能场景，对一致性要求不是极端严格
ZooKeeper锁 中 高 复杂 高可靠性场景，对一致性要求严格

# 分布式锁的最佳实践

# 1. 锁的粒度控制

锁的粒度应该尽可能小，以减少锁的竞争范围。例如，在更新用户信息时，应该只锁定特定用户ID，而不是锁定整个用户表。

# 2. 锁的超时设置

锁的超时时间应该根据业务逻辑合理设置，太短可能导致业务未完成锁就被释放，太长可能导致系统响应变慢。

# 3. 异常处理

在获取锁失败时，应该有合理的重试机制和降级策略，而不是简单地失败返回。

// 带重试机制的锁获取
int retryCount = 0;
int maxRetry = 3;
while (retryCount < maxRetry) {
    try {
        if (tryGetLock()) {
            return;
        }
        retryCount++;
        Thread.sleep(1000 * retryCount); // 指数退避
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("获取锁被中断", e);
    }
}

// 降级处理
handleFallback();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 4. 监控与告警

对分布式锁的获取成功率、持有时间等指标进行监控，及时发现异常情况。

# 结语

分布式锁是分布式系统中的重要基础设施，它解决了分布式环境下的资源竞争问题。本文介绍了分布式锁的基本概念、常见实现方案以及进阶问题，并提供了最佳实践建议。在实际应用中，我们应该根据业务需求和系统特点选择合适的实现方案，并遵循最佳实践来确保系统的稳定性和可靠性。

分布式锁的设计和实现需要考虑多种因素，包括性能、可靠性、一致性等。没有一种方案是完美的，我们需要在具体场景中权衡利弊，选择最适合的方案。

#分布式锁#分布式系统#一致性
上次更新: 2026/01/28, 11:55:25
拜占庭将军问题与PBFT算法详解
分布式Gossip协议：原理、应用与实现

← 分布式Gossip协议：原理、应用与实现→

最近更新
01
LLM
01-30
02
intro
01-30
03
intro
01-30
更多文章>
Theme by Vdoing | Copyright © 2019-2026 Jorgen | MIT License