Quando começamos a dimensionar um aplicativo horizontalmente, podemos nos deparar com um problema que requer bloqueio distribuído.

O bloqueio distribuído parece um problema técnico difícil, mas, em geral, é um problema resolvido. Se você gostou deste artigo, por favor , bata palmas para que outras pessoas possam vê-lo. 💚

Neste post, vou mostrar como implementar um bloqueio distribuído passo a passo baseado em Redis e python.

Bloqueio mais simples

Construir um bloqueio correto no Redis é fácil. Consistia em três etapas:

• Adquira a fechadura,
• Execute algum bloco de código
• Liberte o cadeado

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

• Se não conseguirmos adquirir o bloqueio inicialmente, tentaremos novamente até adquirir o bloqueio ou até que um tempo limite especificado tenha passado.
• Contamos com o comando SETNX , que só definirá um valor de string e retornará 1 se a chave ainda não existir. Se a chave já existe, ele retornará 0.

def release_lock(conn, lock_name, identifier):
    pipe = conn.pipeline(True) 
    lockname = "lock:"+lock_name
while True:
        try:
            # break transaction once lock has been changed,
            pipe.watch(lockname)
            if pipe.get(lockname) == identifier:
               pipe.muti()
               pipe.delete(lockname)
               pipe.execte()
               return True
            
            # execu when identifier not equal
            pipe.unwatch()
            break
        except redis.exceptions.WatchError as e:
            return False
    
    return False

• Usamos o while loop para garantir a correção em tantas situações quanto possível, mesmo se encontrarmos algumas exceções desconhecidas.

Travando com tempo limite

Ao usar um bloqueio, às vezes os clientes podem não conseguir liberar um bloqueio por um motivo ou outro.

Para se proteger contra falhas onde nossos clientes podem travar e deixar um bloqueio no
estado adquirido, adicionaremos um tempo limite, que faz com que o bloqueio seja liberado automaticamente se o processo que possui o bloqueio não terminar dentro do tempo determinado.

def acquire_lock(conn,lock_name,acquire_timeout=10,lock_timeout=10):
identifier = str(uuid.uuid4())
    
    end = time.time() + acquire_timeout
    while time.time() < end:
        if conn.setnx("lock:"+lock_name, identifier)
            conn.expire(lockname, lock_timeout)
            return identifier
        elif not conn.ttl(lockname):
            conn.expire(lockname, lock_timeout)
time.sleep(.001)
    
    return False

O local natural para colocar o EXPIRE é imediatamente após a aquisição da fechadura, e faremos isso. Mas se acontecer de nosso cliente travar (e o pior lugar para ele travar para nós é entre SETNX e EXPIRE), ainda queremos que o bloqueio acabe.

Para lidar com essa situação, sempre que um cliente não conseguir obter o bloqueio, o cliente verificará a validade do bloqueio e, se não estiver definido, defina-o.

Como os clientes verificarão e definirão tempos limite se não conseguirem obter um bloqueio, o bloqueio sempre terá um tempo limite e, eventualmente, expirará, permitindo que outros clientes obtenham um bloqueio com tempo limite esgotado.

O bloqueio distribuído parece um problema técnico difícil, mas, em geral, é um problema resolvido. Se você gostou deste artigo, por favor , bata palmas para que outras pessoas possam vê-lo. 💚