如何使用python使用红锁

Question

我已经工作了几天来理解Redlock，我已经看到锁定的性能大约需要1秒，在我看来，仅仅锁定它似乎有点太多了，但我可能是错的

我创建了一个小脚本：

redis_test.py

import serialized_redis
from pottery import Redlock

redis_connection = serialized_redis.MsgpackSerializedRedis(host='localhost', port=6379, db=0)


def lock(argument):
    return Redlock(key=argument, auto_release_time=120 * 1000)

main.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import math
import random
import sys
import time
from threading import Thread

from loguru import logger

from lib.redis_test import lock, redis_connection


class StopWatch:
    def __init__(self):
        self.start()

    def start(self):
        self._startTime = time.time()

    def getStartTime(self):
        return self._startTime

    def elapsed(self, prec=3):
        prec = 3 if prec is None or not isinstance(prec, int) else prec
        diff = time.time() - self._startTime
        return self.round(diff, prec)

    def round(self, n, p=0):
        m = 10 ** p
        return math.floor(n * m + 0.5) / m


def algorithm_with_lock(random_number):
    print("Keys inside Redis", redis_connection.keys())
    ourWatch = StopWatch()
    ourWatch.start()
    if not redis_connection.exists(f'redlock:{random_number}'):
        # print("Time taken before redis_connection.exists", ourWatch.elapsed()) -> 0.0 seconds
        with lock(f'{random_number}'):
            print("Time taken before redis_connection.exists", ourWatch.elapsed())  # 1.002 seconds
            time.sleep(5)
            redis_connection.set("Hello_world", random.randint(1, 5))
            return True
    else:
        return False


def main():
    while True:
        chosen_number = f"number_{random.randint(1, 3)}"
        response = algorithm_with_lock(chosen_number)

        if response:
            logger.info(f"Yay, finished my job! -> {chosen_number}")
            sys.exit()
        else:
            logger.debug(f"Trying new number! -> {chosen_number}")
            time.sleep(1)


for i in range(1):
    Thread(
        target=main,
    ).start()
    time.sleep(.1)

问题是，实际锁定redis密钥需要很长时间，结果是多个线程可以尝试锁定同一个密钥，而该密钥最终会被卡在锁树中。我的猜测是，实际锁定不应该需要1秒。但我可能是错的，我在这里，我想知道什么可能是长时间锁定的原因，如果有机会我使用它不正确