Comparaison ZooKeeper de l'implémentation Redis des verrous distribués

Avec le développement rapide de la technologie Internet, les systèmes distribués ont été largement utilisés dans les applications modernes, en particulier dans les grandes entreprises Internet. Cependant, dans un système distribué, il est très difficile de maintenir la cohérence entre les nœuds, c'est pourquoi le mécanisme de verrouillage distribué est devenu l'un des fondements pour résoudre ce problème. Dans la mise en œuvre de verrous distribués, Redis et ZooKeeper sont tous deux des outils populaires. Cet article les comparera et les analysera.

1. Redis implémente des verrous distribués

Redis est un système de stockage de données en mémoire open source qui peut être utilisé comme base de données, cache et middleware de messages. Le mécanisme de verrouillage distribué de Redis est implémenté via SETNX. La commande SETNX peut définir de manière atomique la valeur d'une clé, mais elle n'est définie avec succès que lorsque la clé n'existe pas. Par conséquent, nous pouvons implémenter des verrous distribués via SETNX.

Supposons que nous souhaitions implémenter un verrou nommé Lock et que nous devions verrouiller une variable partagée. Vous pouvez utiliser l'exemple de code suivant :

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

Dans le code ci-dessus, la fonction acquire_lock génère un identifiant aléatoire via uuid et le définit via setnx lockname. opère et renvoie l’identifiant si l’opération réussit. Renvoie False si le verrou n’est pas acquis.

Mais il y a un problème ici : si un client a obtenu le verrou, mais plante ou se bloque avant de libérer le verrou, alors les autres clients ne pourront jamais obtenir le verrou, ce qui provoque un problème de blocage. Pour éviter cela, nous pouvons ajouter un délai d'attente pour libérer automatiquement le verrou. Voici le code pour déverrouiller le verrou :

def release_lock(conn, lockname, identifier):
    pip = conn.pipeline(True)
    while True:
        try:
            # watch the lock name to ensure that no one else has acquired the lock
            pip.watch(lockname)
            if pip.get(lockname) == identifier:
                pip.multi()
                pip.delete(lockname)
                pip.execute()
                return True
            pip.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False

L'exemple de code ci-dessus est relativement simple et peut être utilisé directement. Cependant, en utilisation réelle, le scénario de verrouillage distribué est plus complexe et nécessite une solution plus complète. Jetons un coup d'œil à la façon dont ZooKeeper implémente les verrous distribués.

2. ZooKeeper implémente des verrous distribués

ZooKeeper est un service de coordination distribué qui peut être utilisé pour coordonner l'état de différents nœuds dans un système distribué. De nombreux systèmes distribués utilisent ZooKeeper pour coordonner divers nœuds. Dans ZooKeeper, les verrous distribués constituent également un mécanisme très utile.

Le processus de base d'implémentation des verrous distribués dans ZooKeeper est le suivant :

(1) Créer un nœud mutex (Mutex Node)

Tout d'abord, le client doit créer un nœud mutex sur ZooKeeper pour identifier le verrou. Vous pouvez utiliser la commande create pour créer un nœud si le nœud existe déjà, la création échouera. Lors de la création d'un nœud, vous devez spécifier le type de nœud. Les verrous distribués utilisent généralement des nœuds ordonnés de courte durée, c'est-à-dire qu'ils ajoutent un ensemble de nombres après le nom du nœud pour garantir l'unicité du nom du nœud.

(2) Obtention du verrou

Le processus d'acquisition du verrou est le processus de verrouillage du nœud de verrouillage mutex. L'ordre dans lequel les verrous sont acquis est déterminé par l'ordre numérique dans les noms de nœuds. Si le client crée avec succès un nœud mutex, alors il possède le verrou. Si le nœud n'est pas créé avec succès, vous devez attendre que les autres clients libèrent le verrou avant de réessayer.

(3) Libérer le verrou

Lorsque le client n'a plus besoin de verrouiller la ressource, il doit libérer le verrou. La libération du verrou nécessite la suppression du nœud de verrouillage mutex. Une fois le verrou libéré, les autres clients recevront immédiatement le message de libération du verrou via le mécanisme Watcher.

ZooKeeper est plus cher que Redis. Il nécessite le démarrage de services et l'installation et la maintenance des clusters ZooKeeper. Par conséquent, la fréquence d'utilisation de ZooKeeper pour implémenter des verrous distribués dans les systèmes distribués est relativement faible. Cependant, ZooKeeper est relativement plus stable et sécurisé, et convient mieux que Redis pour certains systèmes critiques.

En général, Redis et ZooKeeper sont tous deux des solutions d'implémentation de verrous distribués très pratiques. Lors du choix de la solution à utiliser, vous devez faire un choix en fonction de la situation réelle et faire des compromis en termes de performances, de stabilité, de sécurité, etc. pour obtenir les meilleurs résultats.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!