So verwenden Sie Redis, um verteilte geplante Aufgaben zu implementieren

Redis ist ein hervorragendes Schlüsselwert-Speichersystem, das neben der Verwendung als Cache noch viele andere Verwendungsmöglichkeiten hat. Eines davon dient als Implementierungstool für verteilte geplante Aufgaben. In diesem Artikel stellen wir die Verwendung von Redis zur Implementierung verteilter geplanter Aufgaben vor und stellen entsprechende Codebeispiele bereit.

Was ist eine verteilte geplante Aufgabe?

In einer eigenständigen Umgebung können wir geplante Aufgaben verwenden, um eine bestimmte Funktion oder Aufgabe regelmäßig auszuführen. In einer verteilten Umgebung hat jeder Knoten seine eigenen geplanten Aufgaben, und es können Probleme wie wiederholte Ausführung und verpasste Ausführung auftreten. Daher müssen bei verteilten geplanten Aufgaben Aspekte wie Zuverlässigkeit der Aufgabenausführung, Aufgabenverteilung und -koordination berücksichtigt werden.

Redis als Implementierungstool für verteilte geplante Aufgaben

Redis bietet einige Datenstrukturen und Befehle, die verteilte geplante Aufgaben gut unterstützen können, wie zum Beispiel:

• Sorted Set (geordneter Satz): Sie können der Punktzahl (Score) folgen) Sortieren und zeichnen Sie die Ausführungszeit der Aufgabe anhand von Bewertungen auf.
• Expire-Befehl: Sie können die Ablaufzeit für einen bestimmten Schlüssel festlegen.
• Lua-Skript: In atomaren Operationen können mehrere Befehle ausgeführt werden, um die Atomizität und Zuverlässigkeit der Operationen sicherzustellen.

Als nächstes stellen wir vor, wie man Redis zum Implementieren verteilter geplanter Aufgaben verwendet, und stellen Codebeispiele bereit.

Implementierungsschritte

1. Aufgabeninformationen im Sorted Set of Redis speichern

Zunächst müssen wir die Aufgabeninformationen im Sorted Set of Redis speichern. Hier können wir die Ausführungszeit der Aufgabe (Zeitstempel) als Punktzahl und die ID der Aufgabe als Mitglied angeben. Das Folgende ist ein Beispielcode:

import redis

# Connect to Redis
redis_conn = redis.Redis(host='localhost', port=6379, db=0)

# Add task to Sorted Set
task_id = "task_001"
execute_time = 1600000000  # timestamp (in seconds)
redis_conn.zadd("tasks", {task_id: execute_time})

Im obigen Code haben wir eine Aufgabe namens task_001 ausgeführt, und die Ausführungszeit betrug 1600000000 (hier tatsächlich ausgedrückt durch Zeitstempel). es kann auch anders ausgedrückt werden). Speichern Sie es in einem sortierten Satz mit dem Namen tasks. task_001的任务，执行时间为1600000000 （这里是用时间戳来表示的，实际上也可以使用其他方式来表示）。将它存入名为tasks的Sorted Set中。

2. 设置过期时间

为了避免过期任务一直存在Redis中占用空间，我们需要设置过期时间，并在过期后从Sorted Set中删除。下面是一个示例代码：

import time

# Check for expired tasks every 10 seconds
while True:
    # Get all tasks with score less than current time
    tasks = redis_conn.zrangebyscore("tasks", 0, int(time.time()))

    # Delete expired tasks
    for task in tasks:
        redis_conn.zrem("tasks", task)

以上代码中，我们每隔10秒检查一次过期任务并删除。为此，我们使用了zrangebyscore命令，获取分数在0（即当前时间） 至 time.time()（当前时间戳）之间的任务。在获取到任务后，我们使用了zrem命令，从Sorted set中删除任务。

3. 执行任务

在检查过期任务时，我们同时也要执行这些过期任务。下面是一个示例代码：

import uuid

# Consume tasks every 10 seconds
while True:
    # Get all tasks with score less than current time
    tasks = redis_conn.zrangebyscore("tasks", 0, int(time.time()))

    # Execute tasks
    for task in tasks:
        # Check if task is already being executed by another worker
        lock_id = redis_conn.get("lock_" + task)
        if lock_id is None:
            # Lock task using Lua script
            lock_id = str(uuid.uuid4())
            lua_script = """
                if redis.call("get", ARGV[1]) == false then
                    redis.call("set", ARGV[1], ARGV[2])
                    redis.call("expire", ARGV[1], 60)
                    return true
                else
                    return false
                end
            """
            if redis_conn.eval(lua_script, 0, "lock_" + task, lock_id) is True:
                # Execute task
                print("Executing task " + task)
                # task.execute()
                # ...

                # Remove task from Sorted Set and unlock
                redis_conn.zrem("tasks", task)
                redis_conn.delete("lock_" + task)

以上代码中，我们每隔10秒检查一次过期任务并执行。为此，我们使用了zrangebyscore命令，获取分数在0（即当前时间） 至 time.time()

2. Ablaufzeit festlegen

Um zu verhindern, dass abgelaufene Aufgaben immer Platz in Redis beanspruchen, müssen wir die Ablaufzeit festlegen und sie nach Ablauf aus dem sortierten Satz löschen. Hier ist ein Beispielcode:

rrreee

Im obigen Code prüfen wir alle 10 Sekunden, ob abgelaufene Aufgaben vorliegen, und löschen diese. Dazu verwenden wir den Befehl zrangebyscore, um den Score zwischen 0 (d. h. der aktuellen Zeit) und time.time() (der aktuellen Zeit) zu erhalten aktueller Zeitstempel) zwischen Aufgaben. Nachdem wir die Aufgabe erhalten hatten, verwendeten wir den Befehl zrem, um die Aufgabe aus dem Sorted-Satz zu löschen. 🎜🎜3. Aufgaben ausführen🎜🎜Bei der Überprüfung abgelaufener Aufgaben müssen wir diese abgelaufenen Aufgaben auch gleichzeitig ausführen. Das Folgende ist ein Beispielcode: 🎜rrreee🎜Im obigen Code prüfen wir alle 10 Sekunden, ob abgelaufene Aufgaben vorliegen, und führen diese aus. Dazu verwenden wir den Befehl zrangebyscore, um den Score zwischen 0 (d. h. der aktuellen Zeit) und time.time() (der aktuellen Zeit) zu erhalten aktueller Zeitstempel) zwischen Aufgaben. Nachdem wir die Aufgabe erhalten haben, prüfen wir zunächst, ob die Aufgabe von einem anderen Prozess ausgeführt wird. Um zu vermeiden, dass mehrere Prozesse gleichzeitig dieselbe Aufgabe ausführen, verwenden wir eine lock_id, um festzustellen, ob die Aufgabe gesperrt wurde. Wenn die Aufgabe nicht gesperrt ist, verwenden wir ein Lua-Skript, um die Sperre zu erhalten. Nachdem wir die Sperre erworben haben, führen wir die entsprechende Aufgabenoperation aus, löschen die Aufgabe aus dem sortierten Satz und geben schließlich die Sperre frei. 🎜🎜Zusammenfassung🎜🎜In diesem Artikel wird die Verwendung von Redis zum Implementieren verteilter geplanter Aufgaben vorgestellt und entsprechende Codebeispiele bereitgestellt. Durch die Verwendung von Redis-Funktionen wie Sorted Set, Expire-Befehl und Lua-Skript können wir ein äußerst zuverlässiges und effizientes System für verteilte geplante Aufgaben implementieren. Natürlich muss der obige Code noch verbessert und optimiert werden, um unterschiedlichen Anforderungen und Szenarien gerecht zu werden. 🎜

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Redis, um verteilte geplante Aufgaben zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!