【面试场景题】不使用redis、zk如何自己开发一个分布式锁

青鱼入云2025-09-02 9:18

文章目录

要开发一个分布式锁，核心是实现跨进程、跨节点的互斥访问 ，确保同一时刻只有一个客户端能持有锁。不依赖Redis、ZooKeeper等中间件时，可基于数据库 或文件系统实现，但需解决分布式环境下的一致性、超时释放、重入性等问题。以下是基于数据库的分布式锁实现方案：

一、设计目标

一个可靠的分布式锁需满足：

  1. 互斥性：同一时刻只有一个客户端持有锁。
  2. 安全性：锁只能被持有者释放。
  3. 超时释放：防止持有者崩溃导致锁永久占用。
  4. 可用性：多数节点正常时，锁服务可用。
  5. 重入性（可选）：同一客户端可重复获取已持有的锁。

二、基于数据库的分布式锁实现

利用数据库的唯一约束 和事务特性，通过表记录实现锁的抢占与释放。

1. 数据库表设计

创建一张锁表，存储锁标识、持有者信息、过期时间等：

sql 复制代码 
CREATE TABLE distributed_lock (
    lock_key VARCHAR(64) NOT NULL PRIMARY KEY,  -- 锁的唯一标识（如"order:1001"）
    holder_id VARCHAR(64) NOT NULL,             -- 持有者ID（客户端唯一标识）
    expire_time TIMESTAMP NOT NULL,             -- 锁过期时间（防止永久占用）
    version INT NOT NULL DEFAULT 0,             -- 版本号（用于乐观锁，实现重入性）
    UNIQUE KEY uk_lock_key (lock_key)           -- 唯一约束，保证互斥
);
2. 核心逻辑实现
（1）获取锁（抢占锁）

通过INSERT语句的唯一约束实现互斥，结合过期时间避免死锁：

java 复制代码 
/**
 * 获取分布式锁
 * @param lockKey 锁标识
 * @param holderId 客户端唯一ID（如UUID）
 * @param expireSeconds 锁过期时间（秒）
 * @return 是否获取成功
 */
public boolean tryLock(String lockKey, String holderId, int expireSeconds) {
    // 1. 尝试插入锁记录（唯一约束保证只有一个客户端能成功）
    String insertSql = "INSERT INTO distributed_lock (lock_key, holder_id, expire_time, version) " +
                       "VALUES (?, ?, DATE_ADD(NOW(), INTERVAL ? SECOND), 1) " +
                       "ON DUPLICATE KEY UPDATE " +
                       "holder_id = IF(holder_id = ? AND expire_time > NOW(), ?, holder_id), " +
                       "expire_time = IF(holder_id = ? AND expire_time > NOW(), DATE_ADD(NOW(), INTERVAL ? SECOND), expire_time), " +
                       "version = IF(holder_id = ? AND expire_time > NOW(), version + 1, version)";
    
    // 2. 参数：lockKey, holderId, 过期秒数, 重入判断的holderId, 重入时的holderId, 重入判断的holderId, 过期秒数, 重入判断的holderId
    try (Connection conn = dataSource.getConnection();
         PreparedStatement ps = conn.prepareStatement(insertSql)) {
        ps.setString(1, lockKey);
        ps.setString(2, holderId);
        ps.setInt(3, expireSeconds);
        ps.setString(4, holderId);
        ps.setString(5, holderId);
        ps.setString(6, holderId);
        ps.setInt(7, expireSeconds);
        ps.setString(8, holderId);
        
        int rows = ps.executeUpdate();
        // 3. 插入成功（rows=1）或重入更新成功（rows=2），均表示获取锁成功
        return rows > 0;
    } catch (SQLException e) {
        // 唯一约束冲突时，说明锁已被其他客户端持有
        return false;
    }
}

逻辑说明：

  • 首次获取锁：执行INSERT，若lock_key不存在则成功（rows=1）；若已存在且未过期，触发唯一约束异常（返回false）。
  • 重入锁：若持有者是当前客户端（holder_id匹配）且锁未过期，更新expire_time和version（rows=2），实现重入。
（2）释放锁（主动释放）

通过DELETE或UPDATE释放锁，需校验持有者身份（防止误释放他人锁）：

java 复制代码 
/**
 * 释放分布式锁
 * @param lockKey 锁标识
 * @param holderId 客户端唯一ID
 * @return 是否释放成功
 */
public boolean unlock(String lockKey, String holderId) {
    String deleteSql = "DELETE FROM distributed_lock " +
                       "WHERE lock_key = ? AND holder_id = ?";
    
    try (Connection conn = dataSource.getConnection();
         PreparedStatement ps = conn.prepareStatement(deleteSql)) {
        ps.setString(1, lockKey);
        ps.setString(2, holderId);
        int rows = ps.executeUpdate();
        return rows > 0;  // 只有持有者才能删除成功
    } catch (SQLException e) {
        return false;
    }
}
（3）超时释放（被动释放）

为防止客户端崩溃导致锁永久占用，需定期清理过期锁（可通过定时任务实现）：

java 复制代码 
/**
 * 清理过期锁（定时任务，每30秒执行一次）
 */
@Scheduled(fixedRate = 30000)
public void cleanExpiredLocks() {
    String cleanSql = "DELETE FROM distributed_lock WHERE expire_time < NOW()";
    try (Connection conn = dataSource.getConnection();
         PreparedStatement ps = conn.prepareStatement(cleanSql)) {
        ps.executeUpdate();
    } catch (SQLException e) {
        // 日志记录
    }
}

三、关键问题解决

1. 互斥性保证

通过lock_key的唯一约束，确保同一lock_key只能被一个客户端插入成功，实现跨节点互斥。

2. 安全性（防止误释放）

释放锁时通过holder_id校验，只有锁的持有者才能删除记录，避免其他客户端释放不属于自己的锁。

3. 超时机制
  • 主动续期：客户端持有锁期间，可定期调用tryLock（相同holderId）更新expire_time，防止锁过期。
  • 被动清理：定时任务删除过期锁，避免客户端崩溃后锁永久占用。
4. 重入性支持

通过version字段和ON DUPLICATE KEY UPDATE逻辑，同一客户端可重复获取锁（version递增），释放时需对应次数的unlock（或一次全量释放，视需求而定）。

5. 高可用优化
  • 数据库主从+读写分离：主库负责写（抢锁/释放锁），从库可分担定时任务的读压力。
  • 分库分表 ：若锁数量大，可按lock_key哈希分表，分散单表压力。
  • 连接池优化：使用高性能连接池（如HikariCP），避免数据库连接成为瓶颈。

四、局限性与改进方向

  1. 性能瓶颈 ：数据库写入性能有限（单机每秒数万次），高并发场景下抢锁可能成为瓶颈。

    改进：结合本地缓存（如Caffeine），先检查本地是否持有锁，减少数据库访问。

  2. 事务阻塞 ：若数据库事务未及时提交，可能导致锁记录未生效，需确保tryLock和unlock在独立事务中执行（autoCommit=true）。

  3. 主从延迟风险 ：若使用主从架构，主库写入后未同步到从库，可能导致从库定时任务误删未过期锁。

    改进：定时任务仅从主库读取数据。

五、完整代码示例

java 复制代码 
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.UUID;

public class DatabaseDistributedLock {
    private final DataSource dataSource;
    // 客户端唯一标识（启动时生成，确保同客户端唯一）
    private final String holderId = UUID.randomUUID().toString();

    public DatabaseDistributedLock(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 获取分布式锁
     * @param lockKey 锁标识
     * @param expireSeconds 过期时间（秒）
     * @return 是否获取成功
     */
    public boolean tryLock(String lockKey, int expireSeconds) {
        String sql = "INSERT INTO distributed_lock (lock_key, holder_id, expire_time, version) " +
                   "VALUES (?, ?, DATE_ADD(NOW(), INTERVAL ? SECOND), 1) " +
                   "ON DUPLICATE KEY UPDATE " +
                   "holder_id = IF(holder_id = ? AND expire_time > NOW(), ?, holder_id), " +
                   "expire_time = IF(holder_id = ? AND expire_time > NOW(), DATE_ADD(NOW(), INTERVAL ? SECOND), expire_time), " +
                   "version = IF(holder_id = ? AND expire_time > NOW(), version + 1, version)";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            conn.setAutoCommit(true); // 独立事务，避免锁未提交
            ps.setString(1, lockKey);
            ps.setString(2, holderId);
            ps.setInt(3, expireSeconds);
            ps.setString(4, holderId);
            ps.setString(5, holderId);
            ps.setString(6, holderId);
            ps.setInt(7, expireSeconds);
            ps.setString(8, holderId);

            int rows = ps.executeUpdate();
            return rows > 0;
        } catch (SQLException e) {
            return false;
        }
    }

    /**
     * 释放分布式锁
     * @param lockKey 锁标识
     * @return 是否释放成功
     */
    public boolean unlock(String lockKey) {
        String sql = "DELETE FROM distributed_lock " +
                   "WHERE lock_key = ? AND holder_id = ?";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            conn.setAutoCommit(true);
            ps.setString(1, lockKey);
            ps.setString(2, holderId);
            int rows = ps.executeUpdate();
            return rows > 0;
        } catch (SQLException e) {
            return false;
        }
    }

    /**
     * 清理过期锁（定时任务调用）
     */
    public void cleanExpiredLocks() {
        String sql = "DELETE FROM distributed_lock WHERE expire_time < NOW()";
        try (Connection conn = dataSource.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            conn.setAutoCommit(true);
            ps.executeUpdate();
        } catch (SQLException e) {
            // 记录日志
            e.printStackTrace();
        }
    }
}

六、使用示例

java 复制代码 
// 初始化数据源（如HikariCP）
DataSource dataSource = createDataSource();
// 创建分布式锁实例
DatabaseDistributedLock lock = new DatabaseDistributedLock(dataSource);

// 尝试获取锁（过期时间30秒）
String lockKey = "order:1001";
if (lock.tryLock(lockKey, 30)) {
    try {
        // 执行临界区操作（如扣减库存）
        processOrder();
    } finally {
        // 释放锁
        lock.unlock(lockKey);
    }
} else {
    // 获取锁失败（如返回"系统繁忙，请重试"）
}

总结

基于数据库的分布式锁实现简单，无需依赖额外中间件，适合中小规模分布式场景。其核心是通过唯一约束实现互斥 、过期时间防止死锁 、持有者校验保证安全。但在高并发场景下，需通过分库分表、本地缓存等方式优化性能，或考虑基于分布式文件系统（如NFS）的实现（原理类似，通过文件独占锁实现互斥）。

相关推荐
茉莉玫瑰花茶4 小时前
Redis - Bitmap 类型
数据库·redis·缓存
San304 小时前
JavaScript 流程控制与数组操作全解析：从条件判断到数据高效处理
javascript·面试·代码规范
顾林海4 小时前
揭秘Android编译插桩：ASM让你的代码"偷偷"变强
android·面试·性能优化
倔强青铜三4 小时前
苦练Python第54天：比较运算魔术方法全解析，让你的对象“懂大小、能排序”！
人工智能·python·面试
倔强青铜三5 小时前
苦练Python第53天：数值运算魔术方法从入门到精通
人工智能·python·面试
weixin_436525075 小时前
芋道源码 - RabbitMQ + WebSocket 实现分布式消息推送
分布式·websocket·rabbitmq
飞鱼&5 小时前
RabbitMQ-消息堆积
分布式·rabbitmq
zcyf08095 小时前
rabbitmq分布式事务
java·spring boot·分布式·rabbitmq
北欧柠檬酸海豹6 小时前
Kafka
分布式·kafka
熙客6 小时前
Session与JWT安全对比
java·分布式·安全·web安全·spring cloud
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南03Multisim使用教程详尽版--(2025最新版)04KGG转MP3工具|非KGM文件|解密音频05UV安装并设置国内源0646个Nano-banana 精选提示词，持续更新中07Spec-Kit 使用指南08VsCode远程Copilot无法使用Claude Agent问题09jdk21下载、安装（Windows、Linux、macOS）10阿里最新开源Wan2.2-Animate-14B 本地部署教程：统一双模态框架，MoE架构赋能电影级角色动画与替换