redis 分布式锁 死锁

Redis分布式锁是一种利用Redis的数据结构（如Set、List等）实现的分布式同步机制，用于解决多节点并发下的资源互斥访问问题。当一个节点需要获取某项资源时，会设置一个名为`lock_key`的唯一标识符，并将其值设为当前节点的身份信息，例如主键ID。其他节点如果也尝试获取同一锁，就会发现这个键已经存在，表示锁已被占用。

死锁发生在两个或更多进程在执行过程中，因争夺资源而造成的一种相互等待的现象。在这种情况下，每个进程都在等待对方释放资源，导致所有进程都无法继续执行下去。在Redis分布式锁中，防止死锁的关键在于正确的锁管理和超时策略：

1. **顺序加锁**：确保锁的获取总是按照一定的顺序进行，避免循环依赖导致的死锁。
2. **超时机制**：设置合理的锁持有时间，在一段时间内未成功获得锁或完成操作，则自动释放锁并重试，防止长时间占用锁。
3. **公平锁**：有的实现可以选择公平模式，确保最先请求锁的线程优先获取，但这可能导致性能开销增加。

相关问题

使用了redis分布式锁避免死锁的代码

以下是一个使用 Redis 分布式锁避免死锁的示例代码：

import redis
import time

class RedisLock(object):
    def __init__(self, key, timeout=10, sleep=0.1):
        self.key = key
        self.timeout = timeout
        self.sleep = sleep
        self.redis = redis.Redis(host='localhost', port=6379, db=0)

    def acquire(self):
        while self.timeout >= 0:
            now = time.time()
            expires = now + self.timeout + 1  # 锁的超时时间
            if self.redis.setnx(self.key, expires):  # 尝试获取锁
                return expires
            else:
                current_value = self.redis.get(self.key)
                if current_value and now > float(current_value):  # 判断锁是否已经过期
                    old_value = self.redis.getset(self.key, expires)
                    if old_value and old_value == current_value:  # 防止多个进程同时释放锁
                        return expires
            self.timeout -= self.sleep
            time.sleep(self.sleep)
        return False

    def release(self):
        self.redis.delete(self.key)

# 使用示例
lock = RedisLock("my_lock")
expires = lock.acquire()
if expires:
    # 获取锁成功，执行需要加锁的代码
    print("do something...")
    lock.release()
else:
    print("failed to get lock")

这个示例代码中，我们使用了 Redis 的 SETNX 命令来尝试获取锁。如果获取锁成功，那么 SETNX 命令会返回 1，并且我们会得到一个锁的超时时间。如果获取锁失败，我们会检查锁是否已经过期，如果过期了，我们会使用 GETSET 命令来尝试更新锁的超时时间。如果 GETSET 命令返回的值与之前一样，说明我们成功获取了锁。如果 GETSET 命令返回的值与之前不一样，说明有其他进程已经获取了锁。

redis分布式锁 zookeeper分布式锁

### 比较 Redis 和 Zookeeper 实现分布式锁

#### Redis 分布式锁的特点
Redis 是一种内存中的数据结构存储系统，可以用来作为数据库、缓存和消息中间件。当用于实现分布式锁时，主要依赖于其原子操作命令 `SET` 来确保只有一个客户端能够成功设置某个键并获得锁。

优点在于速度非常快，因为所有的读写都在内存中完成；另外，配置相对简单，易于部署和维护。然而，由于单点故障的风险以及网络分区可能导致的部分节点无法连接到 Redis 服务器等问题，在某些情况下可能会导致死锁或者活锁现象[^1]。

public boolean tryAcquireLock(String lockKey, int timeoutSeconds) {
    Jedis jedis = null;
    String value = UUID.randomUUID().toString();
    
    try {
        jedis = jedisPool.getResource();
        
        // 使用 SETNX 命令尝试加锁
        String result = jedis.set(lockKey, value, "NX", "EX", timeoutSeconds);
        
        return "OK".equals(result);
    } catch (Exception e) {
        throw new RuntimeException(e.getMessage());
    } finally {
        if (jedis != null) {
            jedis.close();
        }
    }
}

#### Zookeeper 分布式锁的特点
Zookeeper 设计之初就是为了处理分布式系统的协调问题，因此在实现分布式锁方面具有天然的优势。通过创建临时有序节点（Ephemeral Sequential Nodes），各个竞争者按照顺序排队等待获取资源。一旦当前持有者的会话结束，则下一个序号最小的参与者自动成为新的拥有者而无需额外通知机制。

这种方式不仅提供了更强的一致性保障，而且即使遇到机器宕机等情况也能很好地恢复。不过相比起 Redis 的简易架构来说，安装配置过程较为复杂一些，并且需要更多的硬件资源支持集群运行[^2]。

// 创建一个临时顺序节点
String path = zkClient.create("/lock-", "", Lists.newArrayList(), CreateMode.EPHEMERAL_SEQUENTIAL);

List<String> childrenNodes = zkClient.getChildren("/", false);
Collections.sort(childrenNodes);

if (childrenNodes.get(0).equals(path.substring(path.lastIndexOf("/") + 1))) {
    // 成功获得了锁
} else {
    // 找到前驱节点并注册监听器
    Watcher watcher = event -> {
        if (event.getType() == EventType.NodeDeleted) {
            // 当前节点前面的那个被删除了，意味着自己成为了第一个节点
            acquireLock();
        }
    };
    
    zkClient.exists(getPreviousNodePath(path), watcher);
}

private void acquireLock() {
    List<String> childrenNodes = zkClient.getChildren("/", false);
    Collections.sort(childrenNodes);
    
    if (childrenNodes.get(0).equals(this.path)) {
        System.out.println("Successfully acquired the lock.");
    } else {
        registerWatcherForPredecessor();
    }
}