Saling kendali Pada Python kemas kini sokongan async

Sudah agak lama sejak kemas kini IoP terakhir saya. Jom kejar!

Peningkatan ketara telah ditambahkan pada antara muka baris arahan IoP:

• Perubahan Nama: Modul grongier.pex telah dinamakan semula kepada iop untuk diselaraskan dengan penjenamaan baharu projek.
• Sokongan Asynchronous: IoP kini menyokong sepenuhnya fungsi tak segerak dan coroutine.

Penamaan Semula Projek

Modul grongier.pex kekal boleh diakses untuk keserasian ke belakang tetapi akan dialih keluar dalam keluaran akan datang. Gunakan modul iop untuk pembangunan baharu.

Fungsi Tak Segerak

Walaupun IoP telah lama menyokong panggilan tak segerak, penggunaan langsung fungsi tak segerak dan coroutine sebelum ini tidak tersedia. Sebelum meneroka ciri baharu ini, mari semak cara panggilan tak segerak berfungsi dalam InterSystems IRIS dan periksa dua contoh.

Panggilan Asynchronous Legasi

Ini menggambarkan pendekatan tradisional:

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}")

Ini mencerminkan gelagat panggilan tak segerak dalam IRIS. send_request_async menghantar permintaan kepada Operasi Perniagaan dan on_response mengendalikan respons yang diterima. completion_key membezakan respons.

Fungsi Berbilang Permintaan Segerak

Walaupun bukan sepenuhnya baharu, keupayaan untuk menghantar berbilang permintaan segerak secara serentak patut diberi perhatian:

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}")

Contoh ini menghantar dua permintaan secara serentak kepada Operasi Perniagaan yang sama. Respons ialah tuple yang mengandungi sasaran, permintaan, respons dan status untuk setiap panggilan. Ini amat berguna apabila pesanan permintaan tidak penting.

Fungsi Tak Segerak dan Coroutine

Berikut ialah cara untuk memanfaatkan fungsi async dan coroutine dalam IoP:

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)

Ini menghantar berbilang permintaan serentak menggunakan send_request_async_ng. asyncio.gather memastikan semua respons ditunggu serentak.

Jika anda telah mengikuti sejauh ini, sila komen "Boomerang"! Ia akan sangat bermakna. Terima kasih!

await_response ialah coroutine yang menghantar berbilang permintaan dan menunggu semua jawapan.

Kelebihan menggunakan fungsi async dan coroutine termasuk prestasi yang dipertingkatkan melalui permintaan selari, kebolehbacaan dan kebolehselenggaraan yang dipertingkatkan, peningkatan fleksibiliti menggunakan modul asyncio dan pengendalian pengecualian dan tamat masa yang lebih baik.

Perbandingan Kaedah Asynchronous

Apakah perbezaan utama antara send_request_async, send_multi_request_sync dan send_request_async_ng?

• send_request_async: Menghantar permintaan dan menunggu jawapan hanya jika on_response dilaksanakan dan completion_key digunakan. Mudah tetapi kurang berskala untuk permintaan selari.
• send_multi_request_sync: Menghantar berbilang permintaan serentak dan menunggu semua jawapan. Mudah digunakan, tetapi pesanan tindak balas tidak dijamin.
• send_request_async_ng: Menghantar berbilang permintaan serentak dan menunggu semua respons, mengekalkan susunan respons. Memerlukan fungsi async dan coroutine.

Selamat berbilang benang!

Atas ialah kandungan terperinci Saling kendali Pada Python kemas kini sokongan async. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!