进程如何释放不属于该进程的 redis 锁？

我有同样的问题。

“LockNotOwnedError（”无法释放锁“\nredis.exceptions.LockNotOwnedError：无法释放不再拥有的锁”

Redis = Redis.from_url（redis_url）

    try:
        with redis.lock(name, timeout=timeout, blocking_timeout=blocking_timeout) as redis_lock:
            yield redis_lock
    except RedisLockError as e:
        logger.warning("Cannot acquire lock", name=name, timeout=timeout, blocking_timeout=blocking_timeout)
        raise LockError(f"Cannot acquire lock {name}") from e

有人可以添加一些提示吗？

通过查看 redis 的 python 库源代码，我已经弄清楚了如何释放非拥有的 redis 锁。下面是 multiread-single-write lock 类的修改版本。

# read_write_lock.py
from enum import Enum
from redis import StrictRedis, lock
# data in Redis cache:

# "read_counter_lock_name" : 0
# "read_lock_lock_name" -> read lock, protect "read_counter_lock_name"
# "write_lock_lock_name" -> write lock, protect write data section

class Prefix(Enum):
    READ = 'read_lock_'
    WRITE = 'write_lock_'
    READ_COUNTER = 'read_counter_'

class RedisLockParams(Enum):
    TIMEOUT = 60 # maximum life for the lock in seconds = 60 seconds
    SLEEP_TIME = 0.1 # the amount of time to sleep in seconds per loop iteration
                    # in redis lock's acquire() - sleep then retry
    BLOCKING = True # acquire() should block until the lock has been acquired
    BLOCKING_TIMEOUT = None # maximum amount of time in seconds to spend trying
                            # to acquire the lock


class ReadWriteLock:
    def __init__(self, lock_name: str, redis_host: str, redis_port: int, redis_key: str):
        self.__read_lock_name = Prefix.READ.value + lock_name
        self.__write_lock_name = Prefix.WRITE.value + lock_name
        self.__read_counter_key = Prefix.READ_COUNTER.value + lock_name

        self.__cache = StrictRedis(host = redis_host,
                                port = redis_port,
                                db=0, # up to 16 logical database
                                password = redis_key,
                                ssl=True)
        # set the read counter to 0, if it does not exist.
        self.__cache.setnx(self.__read_counter_key, 0)

        # init the read lock
        self.__read_lock = lock.Lock(self.__cache,
                                    self.__read_lock_name,
                                    RedisLockParams.TIMEOUT.value,
                                    RedisLockParams.SLEEP_TIME.value,
                                    RedisLockParams.BLOCKING.value,
                                    RedisLockParams.BLOCKING_TIMEOUT.value)
        
        # init the write lock
        self.__write_lock = lock.Lock(self.__cache,
                                    self.__write_lock_name,
                                    RedisLockParams.TIMEOUT.value,
                                    RedisLockParams.SLEEP_TIME.value,
                                    RedisLockParams.BLOCKING.value,
                                    RedisLockParams.BLOCKING_TIMEOUT.value)
        

    def acquire_read_lock(self) -> bool:
        write_lock_acquired = False

        self.__read_lock.acquire()
        read_counter = self.__cache.incr(self.__read_counter_key)
        if (read_counter == 1):
            write_lock_acquired = self.__write_lock.acquire() # acquire write lock
        self.__read_lock.release()

        return write_lock_acquired

    def release_read_lock(self):
        read_lock_acquired = self.__read_lock.acquire()

        if read_lock_acquired:
            read_counter = self.__cache.decr(self.__read_counter_key)
            if read_counter == 0:
                if self.__write_lock.owned():
                    self.__write_lock.release()
                else: # if the lock was not owned, just take its token and override
                    write_lock_token = self.__cache.get(self.__write_lock_name)
                    self.__write_lock.local.token = write_lock_token
                    self.__write_lock.release()
            self.__read_lock.release()

    def acquire_write_lock(self) -> bool:
        return self.__write_lock.acquire()

    def release_write_lock(self) -> None:
        self.__write_lock.release()