写一个redis分布式锁代码

### 回答1：
好的，下面是一个示例代码：

import redis

# 连接到 Redis 服务器
r = redis.Redis(host='localhost', port=6379, password='123456')

# 设置锁的超时时间
timeout = 1000

# 尝试获取锁，如果锁被其他客户端获取，则此操作会失败
status = r.setnx('lock_key', 'lock_value')

# 如果获取成功，则设置锁的超时时间
if status:
    r.expire('lock_key', timeout)

# 如果获取失败，则轮询等待，直到获取到锁为止
while not status:
    time.sleep(0.1)
    status = r.setnx('lock_key', 'lock_value')
    if status:
        r.expire('lock_key', timeout)

# 执行具体的业务逻辑
# ...

# 释放锁
r.delete('lock_key')

上面的代码使用了 Redis 的 SETNX 命令来尝试获取锁，如果锁没有被其他客户端获取，则返回 1，表示获取成功。否则，返回 0，表示获取失败。

然后，使用 Redis 的 EXPIRE 命令来设置锁的超时时间，以避免死锁的情况。

最后，使用 Redis 的 DELETE 命令来释放锁。

注意，上面的代码只是一个示例，实际应用中还需要考虑更多的细节，比如锁的重入、锁的自动续期等。

### 回答2：
Redis分布式锁是一种通过Redis的原子操作来实现多个进程或线程之间的互斥访问。下面是一个简单的Redis分布式锁的代码实现示例：

import redis
import time

class RedisDistributedLock:

    def __init__(self, redis_host, redis_port, lock_key, acquire_timeout=10, lock_expire=30):
        self.redis = redis.Redis(host=redis_host, port=redis_port)
        self.lock_key = lock_key
        self.acquire_timeout = acquire_timeout
        self.lock_expire = lock_expire

    def acquire(self):
        end_time = time.time() + self.acquire_timeout
        while time.time() <= end_time:
            if self.redis.set(self.lock_key, 'locked', nx=True, ex=self.lock_expire):
                return True
            time.sleep(0.001)
        return False

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

使用示例：

# 假设Redis运行在localhost的6379端口上
redis_host = 'localhost'
redis_port = 6379

# 分布式锁的键名
lock_key = 'my-distributed-lock'

# 创建Redis分布式锁对象
lock = RedisDistributedLock(redis_host, redis_port, lock_key)

# 尝试获取分布式锁
if lock.acquire():
    try:
        # 获得锁之后执行需要互斥的代码
        print("执行互斥代码")
    finally:
        # 释放锁
        lock.release()
else:
    print("无法获取分布式锁")

以上代码中，`RedisDistributedLock`是一个封装了Redis分布式锁操作的类。在`acquire`方法中，使用`redis.set`命令设置键值对，通过`nx=True`参数实现了只有当键不存在时才进行设置，从而实现了互斥访问。在`release`方法中，使用`redis.delete`命令删除键，释放锁。

使用时，首先创建`RedisDistributedLock`对象，然后调用`acquire`方法尝试获取分布式锁，如果成功获取到锁则执行需要互斥的代码，最后调用`release`方法释放锁。如果获取锁失败，则执行其他逻辑。