Redis: ein leistungsstarkes Tool zum Aufbau hochskalierbarer Systeme

Redis: Ein leistungsstarkes Tool zum Aufbau hochskalierbarer Systeme. Es sind spezifische Codebeispiele erforderlich.

Redis ist ein Open-Source-In-Memory-Datenstrukturspeichersystem, das auch als Nachrichtenwarteschlange und Cache-Datenbank verwendet werden kann. Es ist ein leistungsstarkes Tool, das uns beim Aufbau hochskalierbarer Systeme hilft. In diesem Artikel werden Ihnen einige allgemeine Funktionen von Redis und deren Implementierungscode vorgestellt.

1. Sentinel-Modus

Der Sentinel-Modus von Redis kann uns dabei helfen, eine hohe Verfügbarkeit zu erreichen. Wenn der Masterknoten ausfällt, kann Sentinel automatisch einen neuen Masterknoten auswählen. Das Folgende ist ein einfaches Implementierungsbeispiel für den Sentry-Modus:

Konfigurationsdatei:

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. Verteilte Sperre

In einem verteilten System müssen wir zur Vermeidung von Parallelitätsproblemen verteilte Sperren verwenden, um die gemeinsame Nutzung zu steuern Zugriff auf Ressourcen. Redis kann verteilte Sperren über die Befehle SETNX und GETSET implementieren. Das Folgende ist ein einfaches Beispiel für die Implementierung einer verteilten Sperre in 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. Publish/Subscribe-Modus

Der Publish/Subscribe-Modus von Redis ermöglicht es verschiedenen Clients, in Echtzeit über einen Kanal zu kommunizieren. Das Folgende ist ein einfaches Implementierungsbeispiel des Publish/Subscribe-Musters:

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. Lua-Skript

Redis unterstützt komplexe Vorgänge durch die Ausführung von Lua-Skripten, die atomar sind und effizient in Redis ausgeführt werden können. Das Folgende ist ein einfaches Lua-Skript-Implementierungsbeispiel:

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

Zusammenfassung

Dieser Artikel stellt vier allgemeine Funktionen von Redis vor und bietet entsprechende Codebeispiele. Der Sentinel-Modus und verteilte Sperren können uns helfen, eine hohe Verfügbarkeit und Parallelitätskontrolle zu erreichen. Der Publish/Subscribe-Modus kann uns dabei helfen, Echtzeitkommunikation zu erreichen. Durch das Erlernen dieser Funktionen von Redis können wir besser hoch skalierbare Systeme aufbauen.

Das obige ist der detaillierte Inhalt vonRedis: ein leistungsstarkes Tool zum Aufbau hochskalierbarer Systeme. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!