当在Spring Boot 中使用分布式锁时，你可以借助各种库和技术来实现。其中，Redis 和 ZooKeeper 是两个常用的分布式锁实现工具。下面将展示如何在 Spring Boot 中使用这两种工具实现分布式锁。
优点：
简单易用： Redis 的分布式锁使用简单，通过 Redis 的 setnx 和 expire 命令可以轻松实现。
性能较好： Redis 是内存型数据库，读写速度快，适合高并发的场景。
丰富的数据结构： Redis 提供了丰富的数据结构和操作，可以方便地扩展锁的功能，比如设置超时时间、自动续期等。
缺点：
单点故障： Redis 是一个单点服务，如果 Redis 服务出现故障，可能会导致整个系统的锁失效。
数据一致性： Redis 采用主从复制机制，可能存在数据同步延迟，不适合对数据一致性要求极高的场景。
使用 Redis 实现分布式锁
添加 Redis 依赖
确保在 pom.xml 文件中添加 Redis 依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
编写 Redis 分布式锁的工具类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@Component
public class RedisDistributedLock {
@Autowired
private StringRedisTemplate redisTemplate;
public boolean acquireLock(String lockKey, String value, long expireTime) {
return redisTemplate.opsForValue().setIfAbsent(lockKey, value, expireTime, TimeUnit.MILLISECONDS);
}
public void releaseLock(String lockKey, String value) {
String currentValue = redisTemplate.opsForValue().get(lockKey);
if (currentValue != null && currentValue.equals(value)) {
redisTemplate.delete(lockKey);
}
}
}
在业务代码中使用 Redis 分布式锁
@Autowired
private RedisDistributedLock redisDistributedLock;
public void someMethod() {
String lockKey = "resource-lock";
String value = "unique-value"; // 可以是唯一的标识符
try {
boolean isLocked = redisDistributedLock.acquireLock(lockKey, value, 5000); // 锁定5秒钟
if (isLocked) {
// 执行需要加锁的业务逻辑
// ...
} else {
// 获取锁失败的处理逻辑
// ...
}
} finally {
redisDistributedLock.releaseLock(lockKey, value);
}
}
优点：
高可用性： ZooKeeper 是一个高可用的分布式协调服务，能够保证服务的可用性。
严格的一致性： ZooKeeper 保证了严格的数据一致性，适合对数据一致性要求高的场景。
顺序性： ZooKeeper 提供了顺序节点特性，可以实现公平锁。
缺点：
复杂性： ZooKeeper 的使用较为复杂，需要了解其 API 和一致性模型，对开发者的要求较高。
性能较差： 相比 Redis，ZooKeeper 的性能较差，适合数据量小、对一致性要求高的场景。
使用 ZooKeeper 实现分布式锁
添加 ZooKeeper 依赖
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>${zookeeper.version}</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>${curator.version}</version>
</dependency>
编写 ZooKeeper 分布式锁的工具类
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@Component
public class ZooKeeperDistributedLock {
@Autowired
private CuratorFramework curatorFramework;
public boolean acquireLock(String lockPath, long timeout, TimeUnit timeUnit) throws Exception {
InterProcessMutex lock = new InterProcessMutex(curatorFramework, lockPath);
return lock.acquire(timeout, timeUnit);
}
public void releaseLock(InterProcessMutex lock) throws Exception {
if (lock != null && lock.isAcquiredInThisProcess()) {
lock.release();
}
}
}
在业务代码中使用 ZooKeeper 分布式锁
@Autowired
private ZooKeeperDistributedLock zooKeeperDistributedLock;
public void someMethod() {
String lockPath = "/locks/resource-lock";
InterProcessMutex lock = new InterProcessMutex(zookeeperClient, lockPath);
try {
boolean isLocked = zooKeeperDistributedLock.acquireLock(lock, 5, TimeUnit.SECONDS); // 锁定5秒钟
if (isLocked) {
// 执行需要加锁的业务逻辑
// ...
} else {
// 获取锁失败的处理逻辑
// ...
}
} catch (Exception e) {
// 处理异常
} finally {
try {
zooKeeperDistributedLock.releaseLock(lock);
} catch (Exception e) {
// 处理释放锁时的异常
}
}
}
1. 并发性能需求： 如果对并发性能要求较高，且数据一致性要求不是非常严格，Redis 可能是更好的选择。
2. 数据一致性需求： 如果应用对数据一致性要求很高，对于分布式锁的正确性和可靠性有极高的要求，那么 ZooKeeper 可能更适合。
3. 简易性和成本： 如果在系统中已经使用了 Redis，并且没有对数据一致性有极高要求，那么利用 Redis 实现分布式锁可能更为简单和成本更低。
综上所述，选择 Redis 还是 ZooKeeper 实现分布式锁取决于你的具体场景需求。如果你更看重性能和简易性，Redis 是一个不错的选择；而如果你更关注数据一致性和可靠性，ZooKeeper 则更适合你的需求。在实际应用中，也可以根据具体情况结合两者的优势来实现分布式锁，比如利用 Redis 实现分布式锁的快速性和利用 ZooKeeper 来保证一致性。