分布式锁用于在多个进程或主机之间互斥访问共享资源,是分布式系统里保证数据一致性的基础手段。
锁与分布式锁
锁是一种并发控制机制,保证一项资源在同一时刻只被一个线程使用,其他线程必须排队等待。
程序级别的锁(synchronized、ReentrantLock)只在单个 JVM 内有效,部署多个实例后各锁各的,起不到互斥作用,这时就需要分布式锁:把互斥状态放到一个所有实例都能访问的外部组件上。
三种实现方案对比
- 基于 MySQL 的悲观锁,性能不好,容易写出造成数据库死锁的代码。
- 做法是建一张锁表,申请者在表里插入一条记录,插入成功即获得锁,删除记录即释放锁。
- 单点故障:数据库不可用会导致依赖它的业务全部不可用。
- 死锁:锁记录没有失效时间,持有者进程挂掉或解锁失败后,记录一直存在,其他进程永远拿不到锁。
- 基于 Redis 实现,目前使用最广。
- 高频访问时 Redis 可能成为瓶颈,极端场景下并不适合承担锁的职责。
- 反复重试会增加通信成本,需要限定重试次数;竞争激烈时可能出现部分进程长期拿不到锁。
- 可集群部署,避免单点故障。
- 基于 ZooKeeper 实现,利用临时顺序节点。
- 数据模型是树形结构,从
/开始逐级建节点,每个节点包含数据与子节点。 - 持久节点(PERSISTENT)默认类型,一直存在。
- 持久顺序节点(PERSISTENT_SEQUENTIAL)创建时按时间顺序编号。
- 临时节点(EPHEMERAL)客户端会话结束时自动删除。
- 临时顺序节点(EPHEMERAL_SEQUENTIAL)按时间顺序编号,会话结束删除。
- 具备锁失效机制:持有者崩溃后临时节点随之消失,后续线程可以继续获取锁;性能不如缓存方案,但可靠性较高。
- 羊群效应:所有等待者都监听锁节点,解锁时全体被唤醒争抢,只有一人成功,其余都是无效请求,通信开销大。改进方式是只监听自己前一个顺序节点。
- 数据模型是树形结构,从
- 基于 etcd 实现,原理接近 ZooKeeper,依赖租约与 watch。
- 同样配置下做压测,Redis 性能最好,ZooKeeper 次之,数据库最差;可靠性上 ZooKeeper 由集群保证,没有单点问题。
- 业务并发不高、又需要可靠互斥时,ZooKeeper(配合 Curator)是稳妥选择;追求吞吐量时用 Redis,但要处理丢锁风险。
分布式锁的条件
锁需要满足:分布式互斥、可重入、锁续期、阻塞等待、公平性,以及可接受的加锁与释放开销。
使用场景
- 保证接口幂等,防止重复提交。
- 防止重复消费,比如重复推送消息或发送邮件。
- 防止缓存击穿,比如秒杀活动超卖。
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 释放
单节点下用 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:临时顺序节点
核心原理是临时顺序节点:每个竞争者创建自己的临时顺序节点,编号最小者获得锁;其余监听前一个节点,前驱释放后再重新判断。客户端会话断开后临时节点自动删除,因此不会死锁。
数据模型与常见操作:
- 节点路径创建后不能修改;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 实例依次加锁,半数以上成功才算获取锁,个别实例故障不会导致锁丢失。
操作流程:
- 客户端记录当前时间。
- 依次向 N 个实例执行加锁,命令与单实例相同:
SET key value NX PX,value 带客户端唯一标识。单个实例加锁的超时时间要远小于锁的有效时间,通常设为几十毫秒。 - 全部实例执行完毕后计算总耗时,同时满足两个条件才算成功:
- 在超过半数(≥ N/2+1)的实例上加锁成功;
- 加锁总耗时没有超过锁的有效时间。
- 释放锁时向所有实例执行同一段 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,并对锁的续期与超时做明确约定。