Redis : un outil puissant pour créer des systèmes hautement évolutifs, des exemples de code spécifiques sont requis
Redis est un système de stockage de structure de données en mémoire open source qui peut également être utilisé comme file d'attente de messages et base de données de cache. C'est un outil puissant qui nous aide à construire des systèmes hautement évolutifs. Cet article vous présentera plusieurs fonctionnalités communes de Redis et leur code d'implémentation.
Le mode Sentinelle de Redis peut nous aider à atteindre une haute disponibilité. Lorsque le nœud maître tombe en panne, Sentinel peut automatiquement élire un nouveau nœud maître. Voici un exemple simple d'implémentation du mode sentinelle :
Fichier de configuration :
sentinel monitor mymaster 127.0.0.1 6379 2 sentinel down-after-milliseconds mymaster 5000 sentinel failover-timeout mymaster 60000
Code :
# 使用redis-py实现哨兵模式 import redis sentinel = redis.RedisSentinel( [('127.0.0.1', 26379)], socket_timeout=0.1, ) redis_master = sentinel.master_for('mymaster', socket_timeout=0.1) redis_slave = sentinel.slave_for('mymaster', socket_timeout=0.1) redis_master.set('key', 'value') print(redis_slave.get('key'))
Dans un système distribué, afin d'éviter les problèmes de concurrence, nous devons utiliser des verrous distribués pour contrôler le partage. Accès aux ressources. Redis peut implémenter des verrous distribués via les commandes SETNX et GETSET. Voici un exemple simple d'implémentation du verrouillage distribué Redis :
Code :
import redis class RedisLock(object): def __init__(self, name, acquire_timeout=10, expire_time=60): self.redis = redis.Redis() self.name = 'redis_lock_key_{}'.format(name) self.acquire_timeout = acquire_timeout self.expire_time = expire_time def acquire_lock(self): start_time = time.time() while True: end_time = time.time() if self.redis.setnx(self.name, 1): self.redis.expire(self.name, self.expire_time) return True elif end_time - start_time > self.acquire_timeout: return False time.sleep(0.1) def release_lock(self): self.redis.delete(self.name) redis_lock = RedisLock('test') if redis_lock.acquire_lock(): try: # 操作共享资源 pass finally: redis_lock.release_lock()
Le mode publication/abonnement de Redis permet à différents clients de communiquer en temps réel via un canal. Ce qui suit est un exemple simple d'implémentation du modèle de publication/abonnement :
Code :
import redis import threading def subscribe_channel(redis, channel): pub_sub = redis.pubsub() pub_sub.subscribe(channel) for message in pub_sub.listen(): print(message) redis_sub = redis.StrictRedis(decode_responses=True) redis_pub = redis.StrictRedis(decode_responses=True) redis_thread = threading.Thread(target=subscribe_channel, args=(redis_sub, 'test_channel')) redis_thread.start() redis_pub.publish('test_channel', 'Hello, Redis!')
Redis prend en charge les opérations complexes en exécutant des scripts Lua, qui sont atomiques et peuvent être exécutés efficacement dans Redis. Voici un exemple simple d'implémentation de script Lua :
Code :
import redis redis_client = redis.Redis() add_script = redis_client.register_script(""" local current_value = redis.call('get', KEYS[1]) current_value = tonumber(current_value) or 0 current_value = current_value + tonumber(ARGV[1]) redis.call('set', KEYS[1], current_value) return current_value """) add_script(keys=['test_lua_key'], args=[1])
Résumé
Cet article présente quatre fonctionnalités courantes de Redis et fournit des exemples de code correspondants. Le mode Sentinel et les verrous distribués peuvent nous aider à obtenir une haute disponibilité et un contrôle de concurrence ; le mode publication/abonnement peut nous aider à établir une communication en temps réel et les scripts Lua peuvent nous aider à mettre en œuvre des opérations complexes. En apprenant ces fonctionnalités de Redis, nous pouvons mieux créer des systèmes hautement évolutifs.
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!