Interoperabilität: Asynchrone Unterstützung für Python-Updates

Seit meinem letzten IoP-Update ist eine Weile vergangen. Lasst uns aufholen!

Der IoP-Befehlszeilenschnittstelle wurden wesentliche Verbesserungen hinzugefügt:

• Namensänderung: Das Modul grongier.pex wurde in iop umbenannt, um es an das neue Branding des Projekts anzupassen.
• Asynchrone Unterstützung: IoP unterstützt jetzt vollständig asynchrone Funktionen und Coroutinen.

Projektumbenennung

Das grongier.pex-Modul bleibt aus Gründen der Abwärtskompatibilität zugänglich, wird jedoch in einer zukünftigen Version entfernt. Nutzen Sie das Modul iop für Neuentwicklungen.

Asynchrone Funktionalitäten

Während IoP seit langem asynchrone Aufrufe unterstützt, war die direkte Nutzung asynchroner Funktionen und Coroutinen bisher nicht verfügbar. Bevor wir uns mit dieser neuen Funktion befassen, werfen wir einen Blick auf die Funktionsweise asynchroner Aufrufe in InterSystems IRIS und untersuchen zwei Beispiele.

Alte asynchrone Aufrufe

Dies veranschaulicht den traditionellen Ansatz:

<code class="language-python">from iop import BusinessProcess
from msg import MyMessage


class MyBP(BusinessProcess):

    def on_message(self, request):
        msg_one = MyMessage(message="Message1")
        msg_two = MyMessage(message="Message2")

        self.send_request_async("Python.MyBO", msg_one, completion_key="1")
        self.send_request_async("Python.MyBO", msg_two, completion_key="2")

    def on_response(self, request, response, call_request, call_response, completion_key):
        if completion_key == "1":
            self.response_one = call_response
        elif completion_key == "2":
            self.response_two = call_response

    def on_complete(self, request, response):
        self.log_info(f"Received response one: {self.response_one.message}")
        self.log_info(f"Received response two: {self.response_two.message}")</code>

Dies spiegelt das asynchrone Anrufverhalten in IRIS wider. send_request_async sendet eine Anfrage an einen Geschäftsbetrieb und on_response verarbeitet die empfangene Antwort. completion_key differenziert Antworten.

Synchronisierte Multi-Request-Funktionalität

Die Möglichkeit, mehrere synchrone Anfragen gleichzeitig zu senden, ist zwar nicht ganz neu, aber bemerkenswert:

<code class="language-python">from iop import BusinessProcess
from msg import MyMessage


class MyMultiBP(BusinessProcess):

    def on_message(self, request):
        msg_one = MyMessage(message="Message1")
        msg_two = MyMessage(message="Message2")

        tuple_responses = self.send_multi_request_sync([("Python.MyMultiBO", msg_one),
                                                        ("Python.MyMultiBO", msg_two)])

        self.log_info("All requests have been processed")
        for target, request, response, status in tuple_responses:
            self.log_info(f"Received response: {response.message}")</code>

In diesem Beispiel werden zwei Anfragen gleichzeitig an denselben Geschäftsvorgang gesendet. Die Antwort ist ein Tupel, das Ziel, Anfrage, Antwort und Status für jeden Aufruf enthält. Dies ist besonders nützlich, wenn die Reihenfolge der Anfragen unwichtig ist.

Asynchrone Funktionen und Coroutinen

So nutzen Sie asynchrone Funktionen und Coroutinen in IoP:

<code class="language-python">import asyncio

from iop import BusinessProcess
from msg import MyMessage


class MyAsyncNGBP(BusinessProcess):

    def on_message(self, request):

        results = asyncio.run(self.await_response(request))

        for result in results:
            print(f"Received response: {result.message}")

    async def await_response(self, request):
        msg_one = MyMessage(message="Message1")
        msg_two = MyMessage(message="Message2")

        tasks = [self.send_request_async_ng("Python.MyAsyncNGBO", msg_one),
                 self.send_request_async_ng("Python.MyAsyncNGBO", msg_two)]

        return await asyncio.gather(*tasks)</code>

Dadurch werden mehrere Anfragen gleichzeitig mit send_request_async_ng gesendet. asyncio.gather stellt sicher, dass alle Antworten gleichzeitig erwartet werden.

Wenn Sie bis hierher mitverfolgt haben, kommentieren Sie bitte „Boomerang“! Es würde viel bedeuten. Danke!

await_response ist eine Coroutine, die mehrere Anfragen sendet und auf alle Antworten wartet.

Zu den Vorteilen der Verwendung von asynchronen Funktionen und Coroutinen gehören eine verbesserte Leistung durch parallele Anforderungen, eine verbesserte Lesbarkeit und Wartbarkeit, eine erhöhte Flexibilität durch die Verwendung des asyncio-Moduls sowie eine bessere Ausnahme- und Timeout-Behandlung.

Vergleich asynchroner Methoden

Was sind die Hauptunterschiede zwischen send_request_async, send_multi_request_sync und send_request_async_ng?

• send_request_async: Sendet nur dann eine Anfrage und wartet auf eine Antwort, wenn on_response implementiert ist und completion_key verwendet wird. Einfach, aber für parallele Anfragen weniger skalierbar.
• send_multi_request_sync: Sendet mehrere Anfragen gleichzeitig und wartet auf alle Antworten. Einfach zu verwenden, aber die Reihenfolge der Antworten ist nicht garantiert.
• send_request_async_ng: Sendet mehrere Anfragen gleichzeitig und wartet auf alle Antworten, wobei die Antwortreihenfolge beibehalten wird. Erfordert asynchrone Funktionen und Coroutinen.

Viel Spaß beim Multithreading!

Das obige ist der detaillierte Inhalt vonInteroperabilität: Asynchrone Unterstützung für Python-Updates. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!