Interopérabilité sur la prise en charge asynchrone des mises à jour Python

Cela fait un moment depuis ma dernière mise à jour IoP. Retrouvons-nous !

Des améliorations significatives ont été ajoutées à l'interface de ligne de commande IoP :

• Changement de nom : Le module grongier.pex a été renommé iop pour s'aligner sur la nouvelle image de marque du projet.
• Prise en charge asynchrone : IoP prend désormais entièrement en charge les fonctions et coroutines asynchrones.

Renommer le projet

Le module grongier.pex reste accessible pour des raisons de compatibilité ascendante mais sera supprimé dans une prochaine version. Utilisez le module iop pour de nouveaux développements.

Fonctionnalités asynchrones

Bien que l'IoP prenne depuis longtemps en charge les appels asynchrones, l'utilisation directe des fonctions asynchrones et des coroutines n'était auparavant pas disponible. Avant d'explorer cette nouvelle fonctionnalité, examinons le fonctionnement des appels asynchrones dans InterSystems IRIS et examinons deux exemples.

Appels asynchrones hérités

Cela illustre l'approche traditionnelle :

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

Cela reflète le comportement des appels asynchrones dans IRIS. send_request_async envoie une demande à une opération commerciale et on_response gère la réponse reçue. completion_key différencie les réponses.

Fonctionnalité multi-requêtes synchrone

Bien qu'elle ne soit pas entièrement nouvelle, la possibilité d'envoyer plusieurs requêtes synchrones simultanément est remarquable :

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

Cet exemple envoie simultanément deux requêtes à la même opération commerciale. La réponse est un tuple contenant la cible, la demande, la réponse et le statut pour chaque appel. Ceci est particulièrement utile lorsque l'ordre de la demande n'est pas important.

Fonctions asynchrones et coroutines

Voici comment exploiter les fonctions asynchrones et les coroutines dans 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>

Cela envoie simultanément plusieurs requêtes en utilisant send_request_async_ng. asyncio.gather garantit que toutes les réponses sont attendues simultanément.

Si vous avez suivi jusqu'ici, veuillez commenter "Boomerang" ! Cela signifierait beaucoup. Merci !

await_response est une coroutine qui envoie plusieurs requêtes et attend toutes les réponses.

Les avantages de l'utilisation de fonctions asynchrones et de coroutines incluent des performances améliorées grâce à des requêtes parallèles, une lisibilité et une maintenabilité améliorées, une flexibilité accrue grâce au module asyncio et une meilleure gestion des exceptions et des délais d'attente.

Comparaison des méthodes asynchrones

Quelles sont les principales différences entre send_request_async, send_multi_request_sync et send_request_async_ng ?

• send_request_async : envoie une demande et attend une réponse uniquement si on_response est implémenté et completion_key est utilisé. Simple mais moins évolutif pour les requêtes parallèles.
• send_multi_request_sync : envoie plusieurs demandes simultanément et attend toutes les réponses. Facile à utiliser, mais l'ordre de réponse n'est pas garanti.
• send_request_async_ng : envoie plusieurs demandes simultanément et attend toutes les réponses, en maintenant l'ordre des réponses. Nécessite des fonctions asynchrones et des coroutines.

Bon multithreading !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!