Heim > Datenbank > Redis > Hauptteil

Redis: ein leistungsstarkes Tool zum Aufbau hochskalierbarer Systeme

王林
Freigeben: 2023-11-07 10:45:20
Original
724 Leute haben es durchsucht

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
Nach dem Login kopieren

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'))
Nach dem Login kopieren
  1. 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()
Nach dem Login kopieren
  1. 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!')
Nach dem Login kopieren
  1. 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])
Nach dem Login kopieren

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!

Verwandte Etiketten:
Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage