java代码怎样实现分布式锁 java代码分布式编程的基础教程
实现分布式锁的核心是利用共享存储服务协调多个节点访问资源，1. 使用setnx和expire命令结合uuid和lua脚本，以确保基于redis的方案的唯一性和原子性，适用于高性能场景；2. 基于zookeeper的解决方案是通过创建临时顺序节点和监控前驱节点来实现的。watcher机制用于减少轮询，支持自动释放锁，适用于高可靠性场景；3. 在选择方案时，需要权衡性能、可靠性、复杂性、锁类型以及是否需要自动释放等因素，redis适用于高性能、低延迟的需求，zookeeper适合强一致性要求；4. 避免死锁等常见问题，设置过期时间或临时节点，使用lua脚本确保删除原子，避免提前释放可启用锁续约，合理配置集群参数，支持重新访问可记录线程ID和重新访问次数；5. 其它方案包括数据库行锁，etcd、consul和基于paxos/raft的一致性系统分别适用于不同性能、可靠性和复杂性要求的场景。最终选择应根据实际业务需要进行综合评估。
实现分布式锁的核心在于利用分布式系统中的共享存储服务，如Redis、Zookeeper或数据库协调多个节点访问共享资源。选择哪种方案取决于您的具体需求，如性能、可靠性和复杂性。
解决方案：
以下是基于Redis和Zookeper实现分布式锁的Java代码示例：
立即学习“Java免费学习笔记(深入)；
1. 基于Redis的分布式锁
Redis
SETNX
（Set if Not Exists）命令和
EXPIRE
命令组合可以实现简单的分布式锁。为了避免死锁，需要设置锁的过期时间。
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.UUID;
public class RedisDistributedLock {
private static final String LOCK_PREFIX = "lock:";
private static final String SUCCESS_RESULT = "OK";
private static final Long RELEASE_SUCCESS = 1L;
private JedisPool jedisPool;
public RedisDistributedLock(String host, int port) {
JedisPoolConfig config = new JedisPoolConfig();
// 连接池配置可根据需要调整
jedisPool = new JedisPool(config, host, port);
}
/**
* 尝试获取锁
* @param lockName 锁的名称
* @param expireTime 锁的过期时间，单位：秒
* @return 获得锁成功返回锁的值，失败返回nulll
*/
public String tryLock(String lockName, int expireTime) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
String lockKey = LOCK_PREFIX + lockName;
String lockValue = UUID.randomUUID().toString(); // 锁的值，用于释放锁时的验证
String result = jedis.set(lockKey, lockValue, "NX", "EX", expireTime);
if (SUCCESS_RESULT.equals(result)) {
return lockValue;
}
return null;
} finally {
if (jedis != null) {
jedis.close();
}
}
}
/**
* 释放锁
* @param lockName 锁的名称
* @param lockValue 锁的值
* @return 释放锁是否成功
*/
public boolean releaseLock(String lockName, String lockValue) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
String lockKey = LOCK_PREFIX + lockName;
// 使用Lua脚本保证原子性
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = jedis.eval(script, 1, lockKey, lockValue);
if (RELEASE_SUCCESS.equals(result)) {
return true;
}
return false;
} finally {
if (jedis != null) {
jedis.close();
}
}
}
public void close() {
if (jedisPool != null) {
jedisPool.close();
}
}
public static void main(String[] args) throws InterruptedException {
RedisDistributedLock lock = new RedisDistributedLock("localhost", 6379);
String lockName = "myLock";
String lockValue = lock.tryLock(lockName, 10); // 尝试获得锁，过期时间为10秒
if (lockValue != null) {
try {
System.out.println("成功获取锁，lockValue: " + lockValue);
// 模拟业务逻辑
Thread.sleep(5000);
} finally {
boolean released = lock.releaseLock(lockName, lockValue);
System.out.println("释放锁结果： " + released);
lock.close();
}
} else {
System.out.println("获取锁失败");
lock.close();
}
}
}关键点：
- 锁的唯一标志： 使用UUID作为锁的值，防止其他客户端的锁被误删。
- Lua脚本：Lua脚本： 使用Lua脚本保证删除锁的原子性，避免并发问题。
- 连接池： 利用JedisPol管理Redis连接，提高性能。
2. 基于Zoookeeper的分布式锁
Zookeeper通过创建临时序列节点来实现分布式锁。当客户创建锁节点时，如果该节点是序列号最小的节点，则认为该客户获得锁。释放锁时，删除该节点。
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class ZookeeperDistributedLock {
private static final String ZK_ADDRESS = "localhost:2181";
private static final String LOCK_ROOT_PATH = "/locks";
private static final String LOCK_NODE_PREFIX = "lock-";
private ZooKeeper zkClient;
private String lockPath;
private String currentLockNode;
private CountDownLatch latch = new CountDownLatch(1);
public ZookeeperDistributedLock(String lockName) throws IOException, InterruptedException, KeeperException {
zkClient = new ZooKeeper(ZK_ADDRESS, 5000, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getState() == Event.KeeperState.SyncConnected) {
latch.countDown();
}
}
});
latch.await();
// 检查根节点是否存在，不存在就创造
Stat stat = zkClient.exists(LOCK_ROOT_PATH, false);
if (stat == null) {
zkClient.create(LOCK_ROOT_PATH, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
this.lockPath = LOCK_ROOT_PATH + "/" + lockName;
Stat lockStat = zkClient.exists(this.lockPath, false);
if(lockStat == null){
zkClient.create(this.lockPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
}
/**
* 尝试获取锁
* @param timeout 超时时间，单位:毫秒
* @return 获取锁是否成功
*/
public boolean tryLock(long timeout) throws InterruptedException, KeeperException {
try {
// 创建临时顺序节点
currentLockNode = zkClient.create(lockPath + "/" + LOCK_NODE_PREFIX, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
// 获取所有子节点
List<String> children = zkClient.getChildren(lockPath, false);
Collections.sort(children);
// 假如当前的节点是最小的节点，成功获得锁
if (currentLockNode.equals(lockPath + "/" + children.get(0))) {
return true;
}
// 监控前一节点
String previousNode = null;
for (int i = 0; i < children.size(); i++) {
if (currentLockNode.equals(lockPath + "/" + children.get(i))) {
previousNode = lockPath + "/" + children.get(i - 1);
break;
}
}
final CountDownLatch waitLatch = new CountDownLatch(1);
Watcher watcher = new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getType() == Event.EventType.NodeDeleted) {
waitLatch.countDown();
}
}
};
zkClient.exists(previousNode, watcher);
return waitLatch.await(timeout, TimeUnit.MILLISECONDS); // 等待前一个节点被删除
} catch (KeeperException e) {
// 处理连接断开的情况，再试一次获得锁
if (e.code() == KeeperException.Code.CONNECTIONLOSS) {
return tryLock(timeout);
} else {
throw e;
}
}
}
/**
* 释放锁
*/
public void unlock() throws InterruptedException, KeeperException {
if (currentLockNode != null) {
zkClient.delete(currentLockNode, -1);
currentLockNode = null;
}
}
public void close() throws InterruptedException {
if (zkClient != null) {
zkClient.close();
}
}
public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
ZookeeperDistributedLock lock = new ZookeeperDistributedLock("myLock");
try {
if (lock.tryLock(5000)) { // 尝试获得锁，超时时间5秒
System.out.println("获取锁成功");
Thread.sleep(5000); // 模拟业务逻辑
} else {
System.out.println("获取锁失败");
}
} finally {
lock.unlock();
lock.close();
}
}
}关键点：
- 临时顺序节点： 使用临时顺序节点，确保锁的自动释放，避免死锁。
- Watcher机制： 利用Watcher监控前一个节点的删除事件，减少轮询。
- 连接丢失处理： 处理连接丢失，重新尝试获取锁。
选择Redis还是Zookeper取决于你的应用场景。Redis适用于性能要求高的场景，Zookeper适用于可靠性要求高的场景。此外，还可以考虑使用Redison等包装好的客户端，提供更先进的分布式锁定功能。
如何选择合适的分布式锁实现方案？
选择合适的分布式锁实现方案，需要综合考虑以下几个方面：
- 性能： Redis通常性能更高，因为它基于内存，读写速度快。Zookeper的性能相对较低，因为它需要磁盘写入和节点同步。如果您的应用程序对性能有很高的要求，Redis可能更合适。
- 可靠性： Zookeper具有更高的可靠性，因为它是一种专门为分布式协调设计的服务，具有容错性和数据一致性的保证。虽然Redis也可以通过主复制和Sentinel实现高可用性，但在某些情况下可能存在数据丢失的风险。如果您的应用程序对可靠性有很高的要求，Zookeper可能更合适。
- 复杂度： Redis的实现相对简单，只需要使用
SETNX
和
EXPIRE
命令。Zookeeper的实现相对复杂，需要创建临时顺序节点、监控节点删除事件等。如果您的应用程序需要开发效率，Redis可能更合适。
- 锁的类型： Redis只支持排他锁，即同时只有一个客户端。Zookeeper可以支持多种类型的锁，如排他锁、共享锁等。如果您的应用程序需要支持多种类型的锁，Zookeeper可能更合适。
- 锁是否需要自动释放： 即使客户端出现故障，Zookeeper的临时节点也可以自动释放锁。Redis需要设置锁的过期时间，以避免死锁，但如果客户端在过期前完成操作，锁可能会提前释放。如果您的应用程序需要自动释放锁的功能，Zookeeper可能更合适。
一般来说，Redis适用于性能要求高、可靠性要求低的场景，而Zookeper适用于可靠性要求高、性能要求低的场景。在实际应用中，可根据具体需要进行选择。
如何避免分布式锁的常见问题？
使用分布式锁时，应注意以下常见问题：
- 死锁： 如果客户端在获得锁后出现故障，锁未释放，可能会导致死锁。为了避免死锁，需要设置锁的过期时间或使用Zookeeper的临时节点。
- 提前释放锁： 如果客户端在锁过期之前完成操作，锁可能会提前释放，其他客户端可以获得锁，从而导致并发问题。为了避免提前释放锁，可以使用Lua脚本来确保删除锁的原子性，或者使用Redisson等包装好的客户端。
- 锁的续约： 如果客户端的操作时间超过锁的过期时间，锁可能会自动释放，导致并发问题。为了避免锁自动释放，可以使用锁的续约机制，即当锁即将过期时，客户端会自动延长锁的过期时间。Redison等客户端提供锁的续约功能。
- 脑裂： 在Redis集群中，如果发生脑破裂，即集群分裂成多个独立的子集群，多个客户端可能同时获得锁，从而导致并发问题。为了避免脑破裂，Redis集群的参数需要合理配置，例如设置
min-replicas-to-write
和
min-replicas-max-lag
参数。
- 重入性： 在某些情况下，相同的线程可能需要多次获得相同的锁。如果锁不支持重新进入，可能会导致死锁。为了支持重新进入，可以在锁中记录线程ID和重新进入次数。Redison等客户提供可重新进入锁。
除Redis和ZooKeeper外，还有以下几种实现分布式锁定的方法：
- 数据库： 可使用数据库的行锁或乐观锁实现分布式锁。例如，可以使用
SELECT ... FOR UPDATE
语句获取行锁，或使用版本号实现乐观锁。数据库实现分布式锁的优点简单易懂，缺点是性能低，因为需要磁盘IO。
- etcd： etcd是一种可用于实现分布式锁的分布式键值存储系统。etcd的性能高于Zookeeper，但可靠性相对较低。
- Consul： Consul是一种服务发现和配置管理系统，也可用于实现分布式锁。Consul的优点是使用简单，缺点是性能低。
- 基于Paxos/Raft算法的分布式一致性系统： 基于Paxos/Raft算法的分布式一致性系统，如TiDBBOS、为了实现分布式锁，CockroachDB等。该方案具有可靠性高、复杂性高等优点。
选择哪个方案取决于你的具体需求。如果性能要求很高，可以选择Redis或者ETCD。如果对可靠性要求很高，可以选择基于Paxos/Raft算法的Zookeeper或分布式一致性系统。如果对复杂性有要求，可以选择数据库或者Consul。
以上是java代码如何实现分布式锁 关于java代码分布式编程基础教程的详细信息。
浙公网安备 33010602011771号