Maison > base de données > Redis > le corps du texte

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

王林
Libérer: 2023-11-07 10:45:20
original
698 Les gens l'ont consulté

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
Copier après la connexion

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'))
Copier après la connexion
  1. 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()
Copier après la connexion
  1. 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!')
Copier après la connexion
  1. 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])
Copier après la connexion

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!

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal
À propos de nous Clause de non-responsabilité Sitemap
Site Web PHP chinois:Formation PHP en ligne sur le bien-être public,Aidez les apprenants PHP à grandir rapidement!