架构视界
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
  • 标签索引
  • 2024年

    • 勇闯大A:美债与美元周期
    • 勇闯大A:交易纪律与自我管理
    • 勇闯大A:交易系统分层
    • 勇闯大A:买卖点与止损规则
    • 勇闯大A:债券与资金流向
    • 勇闯大A:微观、宏观与周期
    • Mac 开发环境:新机配置清单
    • 勇闯大A:内外盘与换手率
    • 会计管理:财报阅读与管理报表
    • 会计基础:记账原理与分录
    • 财务入门:财务体系全景
  • 2023年

    • 境外投资:泰国 BOI 申请实务
  • 2022年

    • 企业架构:故障管理与分级响应
    • 企业架构:技术债务的识别、度量与偿还
  • 2021年

    • Python 数据分析:员工分布可视化
    • Python 数据分析:IP 访问折线图
    • Python 数据分析:IP 词云图
    • Redis:RediSearch 全文检索
    • Rust 基础:第一个 CLI 程序
    • Rust 基础:所有权机制
    • Rust 基础:函数与控制流
    • Rust 基础:变量与数据类型
    • Rust 基础:入门与开发环境
    • 企业架构:分布式系统设计
    • 企业架构:编程式权限设计
    • JVM 调优:启动参数与 GC 日志
    • MyBatis 批量插入:三种写法对比
    • 测试:Spring Boot 分层 Mock
    • Redis:布隆过滤器判断元素存在
    • Jenkins:安装配置与应用部署
    • WebClient:非阻塞 HTTP 客户端
    • Drone:Docker 部署轻量 CI
    • Spring AOP:操作审计日志落库
    • Redisson:分布式锁与 RedLock
    • MyBatis 拦截器:雪花算法主键
    • Netty:线程模型与网络编程
    • Redis:SCAN 游标遍历大键空间
    • Jenkins:单机部署与升级脚本
    • Mac:Neo4j 与 Jupyter 安装
    • JavaFX:OpenJDK 11 环境配置
    • Mac:用 jenv 管理 JDK 版本
    • Redis:有序集合实现延时队列
    • Spring Boot 日志:MDC 串联链路
    • 定时任务:Spring 调度与 Cron
    • GoAccess:Nginx 日志分析
    • MyBatis 拦截器:慢 SQL 分析
    • Lucene:倒排索引与中文分词
    • 分布式锁:三种实现方案对比
    • 学习技巧:减少学习排斥心理
    • 动态数据源:多租户数据路由
    • Compose:Spring Boot 三件套
    • Java 阻塞队列:源码与用法
    • Redis:Docker Compose 哨兵
    • Redis:Docker Compose 主从
    • 网络通信:TCP/IP 与 HTTP 基础
  • 2020年

    • 延时队列:DelayQueue 与 Redis 实现
    • MySQL 基础:员工库导入实践
    • 雪花算法:分布式 ID 生成
    • Redis:地理位置查询
    • 抓包:Wireshark 与 Tcpdump
    • SPI:JDK 与 Spring 扩展机制
    • ZooKeeper:概念与集群搭建
    • Spring Boot:集成 JMH 基准测试
    • Wireshark:抓包工具入门
    • Compose:Redis 与 MySQL
    • CentOS 7:Docker 安装部署
    • Netty:源码阅读环境搭建
    • MySQL 基础:SQL 常见用法
    • CentOS 7:Selenium 运行环境
    • Nginx:HTTPS 证书配置
    • JMH:基准测试与 Spring Boot 集成
    • Spring Boot:指定 Tomcat 版本
    • Eureka:实例上下线告警
    • 钉钉告警:应用异常与实例上下线
    • JVM:内存布局、类加载与调优
    • Git:rebase 合并多次提交
    • CentOS 7:OpenResty 部署
  • 2019年

    • Redis CLI:macOS 安装与使用
    • Nginx:访问日志格式
    • 工程规范:可维护代码的写法
    • IntelliJ IDEA:常用插件
    • SkyWalking:源码阅读环境搭建
    • Spring Boot:Redis 超时配置
    • gRPC:ProtoBuf 定义与代码生成
    • Arthas:Java 线上问题诊断
    • Redis:缓存穿透与击穿防护
    • Docker 部署:Elasticsearch
    • Docker 部署:MySQL 5.7 单机
    • Spring Redis:字符串命令封装
    • Docker 部署:ZooKeeper 运行
    • Docker 部署:Redis 单机运行
    • Dubbo:Spring Boot 微服务集成
    • CentOS 7:CMake 源码编译安装
    • 性能度量:吞吐量与 QPS 指标
    • Java 递归:从笔试题到经典问题
    • CentOS 7:ELK 日志平台部署
    • CentOS 7:SonarQube 部署
    • Selenium:Chrome 浏览器自动化
    • JJWT:令牌生成与解析测试
    • Spring 源码:阅读环境搭建
    • JUnit 4:注解、断言与参数化
    • JWT:令牌结构与签名机制
    • FastDFS:架构与文件存取机制
    • XPath:XML 文档节点定位
    • Redis 基础:锁、队列与事务
    • Redis 基础:数据类型与命令
    • MyBatis:Slf4j 日志接入
    • MyBatis:H2 单元测试与 SQL 日志
    • 源码阅读:开源项目环境搭建
    • Git 配置:命令清单与作用域
    • Java 核心:面向对象与基础类型
    • Java 核心:关键字、异常与反射
    • Java 核心:多线程基础
    • Java 核心:同步关键字与线程池
    • Java 核心:锁与并发工具
    • Java 核心:语言基础与并发
    • Dubbo:远程调用与服务治理
    • Java 集合:框架总览与实现对比
    • Maven:生命周期与常用命令
    • MyBatis:执行流程与插件机制
    • Spring:IoC 容器与依赖注入
    • Spring:AOP 与自动装配
    • Spring:事务与启动流程
    • Spring:IoC、AOP 与事务
    • Spring MVC:请求分发与注解
    • MySQL:架构与索引
    • MySQL:事务、锁与 MVCC
    • MySQL:日志与 SQL 优化
    • MySQL:架构、事务与优化
    • Redis 基础:持久化与线程模型
  • 2018年

    • Java HashMap:扩容机制与哈希冲突
    • Java 集合:HashSet 去重原理
    • Java 基础:交换两个变量的值
    • Spring MVC:零 web.xml 改造
    • Mac 开发环境:新机配置清单
    • Log4j:日志分级与按业务拆分
    • Modbus:工业通信协议与 RTU 帧
    • MySQL 基础:子查询与连接查询
    • MySQL 基础:库与表操作
    • MySQL 基础:表操作与查询
    • MySQL 基础:约束、引擎与数据类型
    • MySQL 基础:库表、约束与类型
    • Java 集合:Vector 与 Stack
    • Java 集合:Vector 与 Stack
    • RabbitMQ:CentOS 7 单机部署
    • Redis:CentOS 7 单机部署
    • MongoDB:CentOS 7 单机部署
    • Linux:常用系统与运维命令
    • 注册中心:Eureka 与 ZooKeeper
    • MySQL:CentOS 7 单机部署
    • Git 分支:主分支与临时分支
    • CentOS 7:Java 开发环境部署
    • Java 集合:LinkedList 双向链表
    • Java 集合:ArrayList 动态数组
    • Spring AOP:注解方式实现切面
← 返回博客

分布式锁:三种实现方案对比

2021年1月26日 #企业架构 #Redis #MySQL

分布式锁用于在多个进程或主机之间互斥访问共享资源,是分布式系统里保证数据一致性的基础手段。

锁与分布式锁

锁是一种并发控制机制,保证一项资源在同一时刻只被一个线程使用,其他线程必须排队等待。

程序级别的锁(synchronized、ReentrantLock)只在单个 JVM 内有效,部署多个实例后各锁各的,起不到互斥作用,这时就需要分布式锁:把互斥状态放到一个所有实例都能访问的外部组件上。

三种实现方案对比

  1. 基于 MySQL 的悲观锁,性能不好,容易写出造成数据库死锁的代码。
    • 做法是建一张锁表,申请者在表里插入一条记录,插入成功即获得锁,删除记录即释放锁。
    • 单点故障:数据库不可用会导致依赖它的业务全部不可用。
    • 死锁:锁记录没有失效时间,持有者进程挂掉或解锁失败后,记录一直存在,其他进程永远拿不到锁。
  2. 基于 Redis 实现,目前使用最广。
    • 高频访问时 Redis 可能成为瓶颈,极端场景下并不适合承担锁的职责。
    • 反复重试会增加通信成本,需要限定重试次数;竞争激烈时可能出现部分进程长期拿不到锁。
    • 可集群部署,避免单点故障。
  3. 基于 ZooKeeper 实现,利用临时顺序节点。
    • 数据模型是树形结构,从 / 开始逐级建节点,每个节点包含数据与子节点。
    • 持久节点(PERSISTENT)默认类型,一直存在。
    • 持久顺序节点(PERSISTENT_SEQUENTIAL)创建时按时间顺序编号。
    • 临时节点(EPHEMERAL)客户端会话结束时自动删除。
    • 临时顺序节点(EPHEMERAL_SEQUENTIAL)按时间顺序编号,会话结束删除。
    • 具备锁失效机制:持有者崩溃后临时节点随之消失,后续线程可以继续获取锁;性能不如缓存方案,但可靠性较高。
    • 羊群效应:所有等待者都监听锁节点,解锁时全体被唤醒争抢,只有一人成功,其余都是无效请求,通信开销大。改进方式是只监听自己前一个顺序节点。
  4. 基于 etcd 实现,原理接近 ZooKeeper,依赖租约与 watch。
  • 同样配置下做压测,Redis 性能最好,ZooKeeper 次之,数据库最差;可靠性上 ZooKeeper 由集群保证,没有单点问题。
  • 业务并发不高、又需要可靠互斥时,ZooKeeper(配合 Curator)是稳妥选择;追求吞吐量时用 Redis,但要处理丢锁风险。

分布式锁的条件

锁需要满足:分布式互斥、可重入、锁续期、阻塞等待、公平性,以及可接受的加锁与释放开销。

使用场景

  • 保证接口幂等,防止重复提交。
  • 防止重复消费,比如重复推送消息或发送邮件。
  • 防止缓存击穿,比如秒杀活动超卖。

MySQL:唯一索引加锁

演示代码:Distributed-Lock-Mysql

表结构很简单,lock_id 上的主键唯一约束就是锁;如果需要可重入,再增加持有者与重入次数字段。

CREATE DATABASE IF NOT EXISTS `distributed_lock_mysql`
    DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

CREATE TABLE distributed_lock_mysql.`distributed_lock`
(
    `lock_id`    varchar(50) NOT NULL COMMENT '锁唯一标识',
    `lock_value` varchar(50) NOT NULL COMMENT '锁内容,区分是谁上的锁',
    PRIMARY KEY (`lock_id`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

加锁就是插入记录,主键冲突说明锁已被占用:

INSERT INTO `distributed_lock`(`lock_id`, `lock_value`) VALUES (?, ?);

释放锁时必须带上持有者校验,删除条件里同时匹配 lock_value,否则可能删掉别人重新获取的锁:

DELETE FROM `distributed_lock` WHERE `lock_id` = ? AND `lock_value` = ?;

加锁与解锁代码:

@Autowired
private JdbcTemplate jdbcTemplate;

public Boolean lock(String key, String value) {
    String insertSql = "INSERT INTO `distributed_lock`(`lock_id`, `lock_value`) VALUES (?, ?)";
    try {
        return jdbcTemplate.update(insertSql, key, value) > 0;
    } catch (DuplicateKeyException e) {
        return false;
    }
}

public Boolean unLock(String key, String value) {
    String sql = "DELETE FROM `distributed_lock` WHERE `lock_id` = ? AND `lock_value` = ?";
    return jdbcTemplate.update(sql, key, value) > 0;
}

这种方式没有过期时间,必须配合定时任务清理异常残留的锁记录,否则进程崩溃就会死锁。

Redis:SET NX 与 Lua 释放

演示代码:Distributed-Lock-Redis

单节点下用 SET key value EX 30 NX 创建锁:EX 设置过期时间,NX 表示键不存在时才写入。返回 OK 表示加锁成功,否则说明锁被占用。

127.0.0.1:6379> set lock true ex 30 nx
OK

两个问题必须一起解决:

  • 过期时间太短,业务还没执行完锁就失效,其他线程会拿到锁。过期时间要覆盖业务最长耗时。
  • 释放锁时不能直接 DEL,否则可能删掉别人持有的锁。做法是给 value 写入唯一值(如 UUID),删除前比对。

比对与删除必须原子完成,用 Lua 脚本:

if redis.call('get', KEYS[1]) == ARGV[1]
  then return redis.call('del', KEYS[1])
else
  return 0
end

每次传脚本字符串要浪费网络开销,Redis 还要重复编译,可以用 SCRIPT LOAD 预加载并返回 sha1,之后用 EVALSHA 执行:

EVAL script numkeys key [key ...] arg [arg ...]
EVALSHA sha1 numkeys key [key ...] arg [arg ...]
SCRIPT LOAD script

工具类

@Service
@Slf4j
public class DistributedLockRedisTool {

    private static final String LOCK_PREFIX = "lock:";

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public boolean lock(String key, String value, long expireSeconds) {
        return tryLock(key, value, expireSeconds, TimeUnit.SECONDS, 1, TimeUnit.SECONDS);
    }

    public boolean lock(String key, String value, int retries, long expireSeconds) {
        for (int i = 0; i < retries; i++) {
            if (lock(key, value, expireSeconds)) {
                return true;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
        return false;
    }

    /**
     * 在 acquireTimeout 内自旋获取锁,超时即放弃
     */
    public boolean tryLock(String key, String value, long expireTime, TimeUnit expireTimeUnit,
                           int acquireTimeout, TimeUnit acquireTimeoutUnit) {
        long end = System.currentTimeMillis() + acquireTimeoutUnit.toMillis(acquireTimeout);
        try {
            while (System.currentTimeMillis() < end) {
                Boolean result = redisTemplate.opsForValue()
                        .setIfAbsent(LOCK_PREFIX + key, value, expireTime, expireTimeUnit);
                if (Boolean.TRUE.equals(result)) {
                    log.info("tryLock success {} {}", key, value);
                    return true;
                }
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            log.error("tryLock {} {} error {}", key, value, e.getMessage());
        }
        log.info("tryLock fail {} {}", key, value);
        return false;
    }

    public boolean unlock(String key, String value) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] "
                + "then return redis.call('del', KEYS[1]) "
                + "else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        Long result = redisTemplate.execute(redisScript, Collections.singletonList(LOCK_PREFIX + key), value);
        return Objects.equals(1L, result);
    }
}

测试

@Autowired
DistributedLockRedisTool distributedLockRedisTool;

@Autowired
RedisTemplate<String, String> redisTemplate;

@Test
@Disabled
public void testLock() throws InterruptedException {
    int count = 10;
    String key = UUID.randomUUID().toString();
    CountDownLatch countDownLatch = new CountDownLatch(count);
    ExecutorService executorService = Executors.newFixedThreadPool(count);
    for (int i = 0; i < count; i++) {
        executorService.execute(() -> {
            log.info("lock {} key {}", distributedLockRedisTool.lock(key, key, 10L), key);
            countDownLatch.countDown();
        });
    }
    countDownLatch.await();
    log.info("unlock {} {}", distributedLockRedisTool.unlock(key, key), key);
    executorService.shutdown();
}

十个线程抢同一把锁,只有一个成功:

[pool-2-thread-7] tryLock success 8e19a035-b610-4e68-a385-c133a1975fa8
[pool-2-thread-7] lock true key 8e19a035-b610-4e68-a385-c133a1975fa8
[pool-2-thread-1] tryLock fail 8e19a035-b610-4e68-a385-c133a1975fa8
[pool-2-thread-1] lock false key 8e19a035-b610-4e68-a385-c133a1975fa8
...
[main] unlock true 8e19a035-b610-4e68-a385-c133a1975fa8

集群下的丢锁风险

  • 单机部署简单,但存在单点故障。
  • 主从加哨兵(Sentinel)能自动切换,但锁写到 Master 后还没同步到 Slave,Master 就挂了,选举出的新 Master 没有这把锁,其他线程仍能加锁。
  • Redis Cluster 只是按 slot 分片,一把锁仍然只落在一个 Master 上,和哨兵模式面临同样的问题。
  • 想用 Redis 做可靠的锁,需要额外的二次检查逻辑,或者使用下面介绍的 RedLock。

ZooKeeper:临时顺序节点

演示代码:Distributed-Lock-Zookeeper

核心原理是临时顺序节点:每个竞争者创建自己的临时顺序节点,编号最小者获得锁;其余监听前一个节点,前驱释放后再重新判断。客户端会话断开后临时节点自动删除,因此不会死锁。

数据模型与常见操作:

  • 节点路径创建后不能修改;EPHEMERAL 节点不能有子节点。
  • Watcher 基于节点注册,监听创建、删除、数据变更等事件。
  • Watch 是一次性的,触发后需要重新注册。

先用 Docker 起一个单节点(集群可参照相同方式配置):

docker run -p 2181:2181 --name latest-zookeeper -d zookeeper
docker ps
docker exec -it <容器id> /bin/bash

进入容器后,在 ZooKeeper 的 bin 目录执行 zkCli.sh:

[zk: localhost:2181(CONNECTED) 0] create /path /00000001
Created /path
[zk: localhost:2181(CONNECTED) 1] get /path
/00000001
[zk: localhost:2181(CONNECTED) 2] get /path -s -w
/00000001
cZxid = 0x2
ctime = Tue Jan 11 18:05:54 UTC 2022
mZxid = 0x2
dataVersion = 0
ephemeralOwner = 0x0
numChildren = 0
[zk: localhost:2181(CONNECTED) 3] set /path 00000002
[zk: localhost:2181(CONNECTED) 4] delete /path
[zk: localhost:2181(CONNECTED) 5] get /path
org.apache.zookeeper.KeeperException$NoNodeException: KeeperErrorCode = NoNode for /path

临时节点在建连期间有效,客户端退出后即被删除:

[zk: localhost:2181(CONNECTED) 6] create -e /temp 3
Created /temp
[zk: localhost:2181(CONNECTED) 7] quit
# 重新进入后查询已不存在
[zk: localhost:2181(CONNECTED) 0] get /temp
org.apache.zookeeper.KeeperException$NoNodeException: KeeperErrorCode = NoNode for /temp

配置类

@Configuration
@Slf4j
public class ZookeeperConfig {

    private static final String LOCK_ROOT = "/LOCKS";
    private static final String HOLDER = "/_";

    @Value("${zookeeper.address}")
    private String connectString;

    @Value("${zookeeper.timeout}")
    private int timeout;

    @Bean(name = "zkClient")
    public ZooKeeper zkClient() {
        try {
            final CountDownLatch connected = new CountDownLatch(1);
            ZooKeeper zooKeeper = new ZooKeeper(connectString, timeout, event -> {
                if (Event.KeeperState.SyncConnected == event.getState()) {
                    connected.countDown();
                }
            });
            connected.await();
            init(zooKeeper);
            log.info("init zookeeper success {}", zooKeeper.getState());
            return zooKeeper;
        } catch (Exception e) {
            throw new IllegalArgumentException("init zookeeper error " + e.getMessage());
        }
    }

    private void init(ZooKeeper zooKeeper) throws InterruptedException, KeeperException {
        if (zooKeeper.exists(LOCK_ROOT, false) == null) {
            zooKeeper.create(LOCK_ROOT, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
        // 持有占位节点,保证第一个竞争者之前总有一个可监听的前驱
        if (zooKeeper.exists(LOCK_ROOT + HOLDER, false) == null) {
            zooKeeper.create(LOCK_ROOT + HOLDER, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }
}

工具类

@Slf4j
public class DistributedLockZookeeperTool {

    private static final String LOCK_ROOT = "/LOCKS";
    private static final String LOCK_NODE_NAME = "/_";

    private final ZooKeeper zkClient;
    private final Thread currentThread = Thread.currentThread();
    private String zNode;
    private String watcherKey;

    public DistributedLockZookeeperTool(ZooKeeper zooKeeper) {
        this.zkClient = zooKeeper;
    }

    private final Watcher watcher = event -> {
        if (event.getType() == Watcher.Event.EventType.NodeDeleted
                && Objects.equals(watcherKey, event.getPath())) {
            LockSupport.unpark(currentThread);
        }
    };

    public boolean tryLock() throws InterruptedException, KeeperException {
        // 临时顺序节点,路径形如 /LOCKS/_0000000001
        this.zNode = zkClient.create(LOCK_ROOT.concat(LOCK_NODE_NAME), new byte[0],
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        waitForLock();
        log.info("lock {}", zNode);
        return true;
    }

    private void waitForLock() throws InterruptedException, KeeperException {
        List<String> children = zkClient.getChildren(LOCK_ROOT, false);
        Collections.sort(children);
        int index = children.indexOf(zNode.substring(LOCK_ROOT.length() + 1));
        if (index <= 0) {
            return;
        }
        String previous = children.get(index - 1);
        if (LOCK_NODE_NAME.substring(1).equals(previous)) {
            // 前驱只是占位节点,本身不持锁
            return;
        }
        watcherKey = LOCK_ROOT + "/" + previous;
        if (zkClient.exists(watcherKey, watcher) != null) {
            LockSupport.park();
        }
        waitForLock();
    }

    public List<String> list() throws InterruptedException, KeeperException {
        return zkClient.getChildren(LOCK_ROOT, false);
    }

    public void close() throws Exception {
        log.info("unlock {}", zNode);
        zkClient.delete(zNode, -1);
    }
}

测试

@Slf4j
@SpringBootTest(classes = AppApplication.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
public class AppApplicationTest {

    @Autowired
    DistributedLockZookeeperTool distributedLockZookeeperTool;

    @Test
    @Disabled
    public void testLock() throws Exception {
        int count = 10;
        String key = UUID.randomUUID().toString();
        CountDownLatch countDownLatch = new CountDownLatch(count);
        ExecutorService executorService = Executors.newFixedThreadPool(count);
        for (int i = 0; i < count; i++) {
            executorService.execute(() -> {
                try {
                    log.info("lock {} key {}", distributedLockZookeeperTool.tryLock(), key);
                    distributedLockZookeeperTool.close();
                } catch (Exception e) {
                    log.error("lock error {}", e.getMessage());
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
    }
}

前驱释放后才会唤醒下一个节点,线程按创建顺序依次看到 lock 与 unlock 日志。

Curator:封装好的 ZooKeeper 锁

原生 API 需要自己处理会话重连、监听重注册、异常分支,生产环境建议直接用 Apache Curator,它提供了可重入互斥锁、不可重入互斥锁、读写锁与集合锁。

@Configuration
public class CuratorConfiguration {

    @Value("${zookeeper.curator.retryCount}")
    private int retryCount;

    @Value("${zookeeper.curator.elapsedTimeMs}")
    private int elapsedTimeMs;

    @Value("${zookeeper.curator.connectString}")
    private String connectString;

    @Value("${zookeeper.curator.sessionTimeoutMs}")
    private int sessionTimeoutMs;

    @Value("${zookeeper.curator.connectionTimeoutMs}")
    private int connectionTimeoutMs;

    @Bean(name = "curatorFramework", initMethod = "start")
    public CuratorFramework curatorFramework() {
        return CuratorFrameworkFactory.newClient(
                connectString,
                sessionTimeoutMs,
                connectionTimeoutMs,
                new RetryNTimes(retryCount, elapsedTimeMs)
        );
    }
}
@Slf4j
@SpringBootTest(classes = AppApplication.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
public class AppApplicationTest {

    @Resource(name = "curatorFramework")
    private CuratorFramework curatorFramework;

    @Test
    @Disabled
    public void testInterProcessMutexLock() throws InterruptedException {
        int count = 10;
        String path = "/LOCKS/" + UUID.randomUUID();
        CountDownLatch countDownLatch = new CountDownLatch(count);
        ExecutorService executorService = Executors.newFixedThreadPool(count);
        for (int i = 0; i < count; i++) {
            executorService.execute(() -> {
                InterProcessMutex lock = new InterProcessMutex(curatorFramework, path);
                try {
                    lock.acquire();
                    log.info("{} 获取到锁", Thread.currentThread().getName());
                    Thread.sleep(2000);
                } catch (Exception e) {
                    log.error("acquire error {}", e.getMessage());
                } finally {
                    try {
                        if (lock.isAcquiredInThisProcess()) {
                            lock.release();
                            log.info("{} 释放锁", Thread.currentThread().getName());
                        }
                    } catch (Exception e) {
                        log.error("release error {}", e.getMessage());
                    }
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await();
        executorService.shutdown();
    }
}

InterProcessMutex 的获取过程与前面手写的工具类一致:创建临时顺序节点,判断自己是否最小;不是最小就监听前驱,前驱删除后重新判断。可参见 Curator 的 internalLockLoop:拿不到锁时对前一个节点注册监听,超时则删除自己的节点并放弃。

Redisson 与 RedLock

Redisson 是基于 Redis 的 Java 驻内存数据网格,除了 Lock,还提供 Map、Set、Queue、Semaphore、CountDownLatch、布隆过滤器等分布式对象与服务。演示代码:Redisson

RedLock 的思路是向 N 个相互独立的 Redis 实例依次加锁,半数以上成功才算获取锁,个别实例故障不会导致锁丢失。

操作流程:

  1. 客户端记录当前时间。
  2. 依次向 N 个实例执行加锁,命令与单实例相同:SET key value NX PX,value 带客户端唯一标识。单个实例加锁的超时时间要远小于锁的有效时间,通常设为几十毫秒。
  3. 全部实例执行完毕后计算总耗时,同时满足两个条件才算成功:
    1. 在超过半数(≥ N/2+1)的实例上加锁成功;
    2. 加锁总耗时没有超过锁的有效时间。
  4. 释放锁时向所有实例执行同一段 Lua 脚本。

主从配置

@Configuration
public class RedisConfig {

    @Bean
    public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
        return new RedissonConnectionFactory(redisson);
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        StringRedisSerializer serializer = new StringRedisSerializer();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(serializer);
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setHashValueSerializer(serializer);
        return redisTemplate;
    }

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useMasterSlaveServers()
                // "rediss://" 表示启用 SSL
                .setMasterAddress("redis://127.0.0.1:6379").setPassword("redis_pwd")
                .addSlaveAddress("redis://127.0.0.1:6380", "redis://127.0.0.1:6381").setPassword("redis_pwd")
                .setRetryInterval(5000)
                .setTimeout(10000)
                .setConnectTimeout(10000);
        return Redisson.create(config);
    }
}

加锁测试

@Autowired
private RedissonClient redissonClient;

@Test
@Disabled
public void testLock() throws InterruptedException {
    int count = 10;
    String lockKey = "redisLock_" + UUID.randomUUID();
    CountDownLatch countDownLatch = new CountDownLatch(count);
    ExecutorService executorService = Executors.newFixedThreadPool(count);
    for (int i = 0; i < count; i++) {
        executorService.execute(() -> {
            RLock lock = redissonClient.getLock(lockKey);
            try {
                // 等待 2 秒获取锁;不指定租约时间时由看门狗自动续期
                if (lock.tryLock(2, TimeUnit.SECONDS)) {
                    log.info("{} lock {}", Thread.currentThread().getName(), lockKey);
                    redissonClient.getBucket("value").set(String.valueOf(System.currentTimeMillis()));
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                    log.info("{} unlock {}", Thread.currentThread().getName(), lockKey);
                }
                countDownLatch.countDown();
            }
        });
    }
    countDownLatch.await();
    executorService.shutdown();
}

tryLock(waitTime, leaseTime, unit) 可以显式指定租约,此时不启用看门狗,业务必须在租约内执行完,否则锁会提前释放。主从切换仍可能丢锁,要求严格互斥时改用 RedissonRedLock 或直接选择 ZooKeeper。

如何选择

方案一致性性能适用场景
MySQL 唯一索引依赖数据库低并发极低、已有数据库、能接受运维清理残留锁
Redis SET NX单实例可靠,主从切换可能丢锁高吞吐量优先,能接受极短的互斥失效窗口
RedLock半数实例成功,强于主从中多个独立 Redis 实例,要求较高
ZooKeeper / Curator集群多数派,可靠中金额、库存等不允许丢锁的业务

小结

数据库靠唯一索引加锁但缺少失效时间,Redis 用 SET NX EX 加 Lua 校验唯一值删锁,ZooKeeper 用临时顺序节点监听前驱;主从切换容易丢锁,生产建议直接用 Curator 或 Redisson,并对锁的续期与超时做明确约定。

最近更新: 2026/11/20 22:30
Contributors: 庆峰
Prev
Lucene:倒排索引与中文分词
Next
学习技巧:减少学习排斥心理