Comment utiliser les verrous Redis pour résoudre les problèmes de concurrence

Utilisez le verrouillage Redis pour gérer les problèmes de concurrence afin de garantir qu'une seule instance d'un multi-processus est en cours d'exécution. Lorsque l'instance en cours d'exécution tombe en panne, l'une des autres instances peut apparaître, garantissant ainsi. qu'il y a et seulement Il y a une instance en cours d'exécution.

import redis
r = redis.Redis(...)

last_heart = 0		# 记录上一次得到的锁心跳
free_lock_try = 6	# 锁无心跳的最大次数 

while not r.setnx('mylock', 1):
    now_heart = r.get('mylock')
    print(f"没获取到锁,now_heart={now_heart},last_heart={last_heart},free_lock_try={free_lock_try}")
    if now_heart == last_heart:
        free_lock_try = free_lock_try - 1
        if free_lock_try == 0:	# 锁已经1分钟没有心跳了
            old_heart = r.getset('mylock', 1)	# 将lock重置为1，并返回set之前的心跳值
            if old_heart < now_heart:
                time.sleep(10)
                continue
            else:
                break	# 成功获取到锁，退出循环
    else:
        free_lock_try = 6	# 锁有心跳，重置free_lock_try值
        last_heart = now_heart
    time.sleep(10)

def producer_exit():
    """程序正常退出时候自动清理锁"""
    r.delete(&#39;mylock&#39;)
import atexit
atexit.register(producer_exit)

# 业务代码
while True:
  r.incr(&#39;mylock&#39;)	# 让锁心跳加一
  ...

Jetons un coup d'œil aux problèmes de verrouillages simultanés que ce programme résout :

1 Sous une concurrence élevée, plusieurs processus ne peuvent pas obtenir de verrous en même temps. Redis.setnx est utilisé ici Si le verrou existe déjà, les autres processus ne peuvent pas réinitialiser le verrou et obtenir le verrou. De plus, lorsque plusieurs processus détectent qu'il y a un verrou et qu'il n'y a pas de battement de cœur en même temps, ils utilisent redis.getset pour réinitialiser le battement de cœur à 1. L'ensemble peut réussir, mais la valeur obtenue par plusieurs processus est différente uniquement lorsque. le verrou est effectivement acquis. Le processus renvoie le battement de cœur du processus précédent, tandis que les autres processus obtiennent 1.

2. Le processus verrouillé se termine normalement. Vous pouvez utiliser atexit pour enregistrer la fonction de sortie du processus pour supprimer le verrou, mais vous devrez attendre plusieurs battements de cœur. au démarrage suivant

3. Le processus verrouillé se termine de manière inattendue et le battement de cœur n'augmentera plus après la sortie. Une fois le nombre de free_lock_try dépassé, les autres processus se réinitialiseront et acquerront le verrou

. 4. Tous les processus se terminent de manière inattendue. Ce problème ne concerne pas les verrous. Vous pouvez utiliser Supervisor pour exécuter le processus démon.

Pour plus de connaissances sur Redis, veuillez faire attention à la colonne Tutoriel d'introduction à Redis.

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!