Redis 中如何实现分布式锁？

import redis
import time

def acquire_lock(client, lock_name, acquire_timeout=10):
    identifier = str(uuid.uuid4())
    end = time.time() + acquire_timeout
    while time.time() < end:
        if client.setnx(lock_name, identifier):
            return identifier
        time.sleep(0.01)
    return False

def release_lock(client, lock_name, identifier):
    pipe = client.pipeline(True)
    while True:
        try:
            pipe.watch(lock_name)
            if pipe.get(lock_name) == identifier:
                pipe.multi()
                pipe.delete(lock_name)
                pipe.execute()
                return True
            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False

import redis
import time
import uuid

def acquire_lock(client, lock_name, acquire_timeout=10, lock_timeout=10):
    identifier = str(uuid.uuid4())
    end = time.time() + acquire_timeout
    while time.time() < end:
        if client.set(lock_name, identifier, ex=lock_timeout, nx=True):
            return identifier
        time.sleep(0.01)
    return False

def release_lock(client, lock_name, identifier):
    pipe = client.pipeline(True)
    while True:
        try:
            pipe.watch(lock_name)
            if pipe.get(lock_name) == identifier:
                pipe.multi()
                pipe.delete(lock_name)
                pipe.execute()
                return True
            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False

import redis
import time
import uuid

class Redlock:
    def __init__(self, nodes, retry_count=3, retry_delay=0.2):
        self.nodes = [redis.StrictRedis(host=node['host'], port=node['port']) for node in nodes]
        self.retry_count = retry_count
        self.retry_delay = retry_delay

    def acquire(self, resource, val, ttl):
        quorum = len(self.nodes) // 2 + 1
        start_time = time.time()

        for retry in range(self.retry_count):
            n = 0
            for node in self.nodes:
                if node.set(resource, val, ex=ttl, nx=True):
                    n += 1
                if n >= quorum:
                    validity_time = ttl - (time.time() - start_time) * 1000
                    if validity_time > 0:
                        return validity_time
            time.sleep(self.retry_delay)

        return 0

    def release(self, resource, val):
        for node in self.nodes:
            try:
                if node.get(resource) == val:
                    node.delete(resource)
            except redis.exceptions.RedisError:
                pass

# 使用示例
nodes = [
    {'host': 'localhost', 'port': 6379},
    {'host': 'localhost', 'port': 6380},
    {'host': 'localhost', 'port': 6381}
]

redlock = Redlock(nodes)
lock_value = str(uuid.uuid4())
lock_ttl = 10  # 锁的超时时间，单位秒

if redlock.acquire('my_lock', lock_value, lock_ttl):
    try:
        # 执行需要加锁的操作
        pass
    finally:
        redlock.release('my_lock', lock_value)