Redis : un outil puissant pour créer des systèmes hautement évolutifs

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.

1. Mode Sentinelle

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'))

2. Verrouillage distribué

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()

3. Mode publication/abonnement

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!')

4. Script Lua

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!