Parallelitätsmuster: Aktives Objekt

Einführung

Das Active Object Pattern ist ein Parallelitätsentwurfsmuster, das die Methodenausführung vom Methodenaufruf entkoppelt. Das Hauptziel dieses Musters besteht darin, asynchrones Verhalten einzuführen, indem Vorgänge in einem separaten Thread ausgeführt werden und gleichzeitig eine synchrone Schnittstelle für den Client bereitgestellt wird. Dies wird durch eine Kombination aus Nachrichtenübermittlung, Anforderungswarteschlangen und Planungsmechanismen erreicht.

Schlüsselkomponenten

1. Proxy: Stellt die öffentliche Schnittstelle zum Client dar. Noch einfacher ausgedrückt ist es das, womit der Kunde interagieren wird. Es übersetzt Methodenaufrufe in Anfragen für das aktive Objekt.
2. Scheduler: Verwaltet die Anforderungswarteschlange und bestimmt die Reihenfolge der Anforderungsausführung.
3. Servant: Enthält die tatsächliche Implementierung der aufgerufenen Methoden. Hier kommt die eigentliche Berechnungslogik zum Einsatz.
4. Aktivierungswarteschlange: Speichert die Anfragen vom Proxy, bis der Scheduler sie verarbeitet.
5. Future/Callback: Ein Platzhalter für das Ergebnis einer asynchronen Berechnung.

Arbeitsablauf

1. Ein Client ruft eine Methode auf dem Proxy auf.
2. Der Proxy erstellt eine Anfrage und stellt sie in die Aktivierungswarteschlange.
3. Der Planer nimmt die Anfrage auf und leitet sie zur Ausführung an den Bediensteten weiter.
4. Das Ergebnis wird über ein zukünftiges Objekt an den Client zurückgegeben.

Anwendungsfälle

• Echtzeitsysteme, die vorhersehbare Ausführungsmuster erfordern.
• GUI-Anwendungen, damit der Hauptthread reaktionsfähig bleibt.
• Verteilte Systeme zur Bearbeitung asynchroner Anfragen.

Durchführung

Nehmen wir an, wir müssen eine Berechnung durchführen, vielleicht einen API-Aufruf, eine Datenbankabfrage usw. Ich werde keine Ausnahmebehandlung implementieren, weil ich zu faul bin.

def compute(x, y):
    time.sleep(2)  # Some time taking task
    return x + y

Ohne aktives Objektmuster

Unten finden Sie ein Beispiel dafür, wie wir gleichzeitige Anfragen ohne Verwendung des Active Object Pattern verarbeiten können.

import threading
import time


def main():
    # Start threads directly
    results = {}

    def worker(task_id, x, y):
        results[task_id] = compute(x, y)

    print("Submitting tasks...")
    thread1 = threading.Thread(target=worker, args=(1, 5, 10))
    thread2 = threading.Thread(target=worker, args=(2, 15, 20))

    thread1.start()
    thread2.start()

    print("Doing other work...")

    thread1.join()
    thread2.join()

    # Retrieve results
    print("Result 1:", results[1])
    print("Result 2:", results[2])


if __name__ == "__main__":
    main()

Nachteile des oben genannten Ansatzes

• Thread-Management:Die direkte Verwaltung von Threads erhöht die Komplexität, insbesondere wenn die Anzahl der Aufgaben wächst.

• Mangelnde Abstraktion: Der Kunde ist für die Verwaltung des Lebenszyklus von Threads verantwortlich und koppelt die Aufgabenverwaltung mit der Geschäftslogik.

• Skalierbarkeitsprobleme: Ohne eine ordnungsgemäße Warteschlange oder einen Planungsmechanismus gibt es keine Kontrolle über die Reihenfolge der Aufgabenausführung.

• Eingeschränkte Reaktionsfähigkeit: Der Client muss warten, bis Threads beitreten, bevor er auf Ergebnisse zugreifen kann.

Implementierung mit Active Object Pattern

Unten finden Sie eine Python-Implementierung des Active Object Pattern, die Threading und Warteschlangen verwendet, um das Gleiche wie oben zu tun. Wir gehen jeden Teil einzeln durch:

MethodRequest: Kapselt die Methode, Argumente und einen Future zum Speichern des Ergebnisses.

def compute(x, y):
    time.sleep(2)  # Some time taking task
    return x + y

Scheduler: Verarbeitet kontinuierlich Anfragen aus der Aktivierungswarteschlange in einem separaten Thread.

import threading
import time


def main():
    # Start threads directly
    results = {}

    def worker(task_id, x, y):
        results[task_id] = compute(x, y)

    print("Submitting tasks...")
    thread1 = threading.Thread(target=worker, args=(1, 5, 10))
    thread2 = threading.Thread(target=worker, args=(2, 15, 20))

    thread1.start()
    thread2.start()

    print("Doing other work...")

    thread1.join()
    thread2.join()

    # Retrieve results
    print("Result 1:", results[1])
    print("Result 2:", results[2])


if __name__ == "__main__":
    main()

Servant: Implementiert die eigentliche Logik (z. B. die Berechnungsmethode).

class MethodRequest:
    def __init__(self, method, args, kwargs, future):
        self.method = method
        self.args = args
        self.kwargs = kwargs
        self.future = future

    def execute(self):
        try:
            result = self.method(*self.args, **self.kwargs)
            self.future.set_result(result)
        except Exception as e:
            self.future.set_exception(e)

Proxy: Übersetzt Methodenaufrufe in Anfragen und gibt einen Future für das Ergebnis zurück.

import threading
import queue


class Scheduler(threading.Thread):
    def __init__(self):
        super().__init__()
        self.activation_queue = queue.Queue()
        self._stop_event = threading.Event()

    def enqueue(self, request):
        self.activation_queue.put(request)

    def run(self):
        while not self._stop_event.is_set():
            try:
                request = self.activation_queue.get(timeout=0.1)
                request.execute()
            except queue.Empty:
                continue

    def stop(self):
        self._stop_event.set()
        self.join()

Client: Übermittelt Aufgaben asynchron und ruft bei Bedarf Ergebnisse ab.

import time


class Servant:
    def compute(self, x, y):
        time.sleep(2)
        return x + y

Vorteile

• Entkoppelte Schnittstelle: Clients können Methoden aufrufen, ohne sich um die Ausführungsdetails kümmern zu müssen.
• Reaktionsfähigkeit: Die asynchrone Ausführung stellt sicher, dass der Client reaktionsfähig bleibt.
• Skalierbarkeit: Unterstützt mehrere gleichzeitige Anfragen.

Nachteile

• Komplexität: Erhöht die architektonische Komplexität.
• Overhead: Erfordert zusätzliche Ressourcen für die Verwaltung von Threads und Warteschlangen.
• Latenz: Asynchrone Verarbeitung kann zu zusätzlicher Latenz führen.

Abschluss

Das Active Object Pattern ist ein leistungsstarkes Tool zur Verwaltung asynchroner Vorgänge in Multithread-Umgebungen. Durch die Trennung des Methodenaufrufs von der Ausführung wird eine bessere Reaktionsfähigkeit, Skalierbarkeit und eine sauberere Codebasis gewährleistet. Obwohl es mit einer gewissen Komplexität und potenziellem Leistungsaufwand verbunden ist, ist es aufgrund seiner Vorteile eine ausgezeichnete Wahl für Szenarien, die eine hohe Parallelität und vorhersehbare Ausführung erfordern. Der Einsatz hängt jedoch von der konkreten Problemstellung ab. Wie bei den meisten Mustern und Algorithmen gibt es keine einheitliche Lösung.

Referenzen

Wikipedia – Aktives Objekt

Das obige ist der detaillierte Inhalt vonParallelitätsmuster: Aktives Objekt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!