Pengaturcaraan Tak Segerak dalam Python: Daripada Asas kepada Penggunaan Dunia Sebenar

Utama » Python » Pengaturcaraan Tak Segerak dalam Python: Daripada Asas kepada Penggunaan Dunia Sebenar

Pengaturcaraan tak segerak dalam Python telah berkembang daripada topik khusus kepada salah satu kemahiran teras bagi sesiapa sahaja yang membina aplikasi moden dan responsif. Jika anda bekerja dengan API web, perkhidmatan mikro, papan pemuka masa nyata atau sebarang jenis input/output (I/O) yang berat, anda mungkin pernah mengalami situasi di mana kod anda menghabiskan lebih banyak masa menunggu daripada melakukan kerja sebenar. Di situlah teknik asinkron menonjol.

Daripada membiarkan program anda terbiar sementara menunggu rangkaian, cakera atau perkhidmatan luaran, kod tak segerak membolehkan anda bertindih dengan tempoh menunggu tersebut dan memastikan aplikasi terus berjalan. Dalam panduan ini, kita akan mengkaji secara mendalam cara async berfungsi dalam Python, masalah yang diselesaikannya, bila ia benar-benar membantu dan bila ia merupakan alat yang salah, dan kita akan menerangkan contoh-contoh konkrit menggunakan async, await, asyncio dan pustaka asinkron yang popular seperti aiohttp.

Apakah Pengaturcaraan Asinkron dalam Python?

Pada terasnya, pengaturcaraan tak segerak ialah cara menstrukturkan kod anda supaya berbilang tugas boleh membuat kemajuan tanpa menyekat satu sama lain, walaupun ia berkongsi satu thread sistem pengendalian. Dalam gaya segerak klasik, setiap operasi selesai sebelum operasi seterusnya bermula: memanggil API, tunggu, menghuraikan respons, barulah teruskan. Dengan kod asinkron, anda boleh mencetuskan beberapa operasi yang berjalan lama dan membiarkan Python bertukar antara satu sama lain apabila salah satu daripadanya hanya menunggu.

Python melaksanakan model ini dengan gabungan sintaks khas dan penjadual koperatif yang dibina di sekitar gelung peristiwa. Dua kata kunci yang membuka kunci semua ini ialah async and await: anda menandakan fungsi sebagai tak segerak menggunakan async def, dan anda berhenti seketika di dalamnya dengan await setiap kali anda mencapai operasi yang boleh menghasilkan kawalan kembali kepada gelung peristiwa.

An async def Fungsi tidak mengembalikan nilai secara langsung; ia mengembalikan objek coroutine yang mewakili pengiraan yang boleh dijadualkan dan ditunggu. Apabila anda menggunakan await Di dalam fungsi itu, Python menggantung coroutine semasa dan membiarkan tugas lain yang belum selesai berjalan sehingga operasi yang ditunggu-tunggu (seperti permintaan rangkaian) selesai, di mana pelaksanaan akan disambung semula sejurus selepas await.

Ini penting: kod Python tak segerak biasanya masih berulir tunggal, tetapi serentak dalam erti kata bahawa berbilang operasi maju dalam tetingkap masa yang bertindih. Sementara satu tugas menunggu I/O, tugas lain mendapat masa CPU. Itulah sebabnya async sesuai untuk beban kerja yang terikat dengan I/O tetapi tidak mempercepatkan kerja yang berat CPU secara ajaib.

Analogi Konkrit: Pameran Catur dan Masa Menunggu

Satu analogi klasik yang digunakan dalam komuniti Python untuk menjelaskan pelaksanaan serentak berbanding pelaksanaan berjujukan berasal daripada pameran catur serentak. Bayangkan seorang grandmaster bermain menentang 24 orang pemain amatur. Dia boleh mengendalikan acara ini dalam dua cara berbeza, mencerminkan strategi segerak dan tak segerak.

Dalam versi segerak, dia duduk dengan seorang lawan dan bermain permainan tunggal itu dari awal hingga akhir sebelum beralih ke meja seterusnya. Setiap gerakan yang dilakukannya mengambil masa 5 saat, manakala setiap pemain amatur menghabiskan masa kira-kira 55 saat untuk berfikir. Permainan biasa mempunyai 30 pertukaran gerakan (jadi jumlah 60 gerakan). Ini bermakna setiap permainan berlangsung (55 + 5) × 30 = 1800 saat, kira-kira 30 minit. Dengan 24 perlawanan, keseluruhan acara berlarutan selama 12 jam.

Dalam versi tak segerak, dia berjalan di sekitar bilik dan membuat satu gerakan di setiap papan, kemudian segera berjalan ke papan seterusnya sementara lawan semasa memikirkan tindak balas mereka. Satu pusingan pergerakan merentasi 24 papan mengambil masa 24 × 5 = 120 saat, atau 2 minit. Selepas 30 pusingan sedemikian, set penuh permainan disiapkan dalam masa kira-kira 3600 saat, iaitu 1 jam.

Kesimpulan penting ialah kelajuan permainannya yang mentah tidak pernah berubah; apa yang berubah ialah cara dia menggunakan masa menunggu pihak lawan. Kod Python tak segerak mengikuti prinsip yang sama: ia tidak menjadikan I/O lebih pantas, tetapi ia memastikan anda melakukan sesuatu yang berguna semasa anda tersekat menunggu rangkaian, cakera atau sebarang sumber luaran.

Permintaan Penyegerakan vs Async: Contoh Dunia Nyata dengan API

Salah satu kes penggunaan yang paling biasa untuk async dalam Python ialah berurusan dengan API luaran, yang mana setiap permintaan boleh mengambil masa ratusan milisaat atau lebih dengan mudah. Sebagai contoh, bayangkan anda ingin mendapatkan bilangan pengikut untuk beberapa akaun GitHub menggunakan API awam mereka.

Pendekatan segerak yang mudah akan menggunakan klien HTTP penyekat yang popular seperti requests. Anda akan melakukan permintaan GET untuk setiap titik akhir pengguna dalam satu gelung, membaca muatan JSON, mengekstrak followers medan dan cetak atau simpannya. Ini mudah dan boleh dibaca, tetapi ia mempunyai kelemahan: untuk setiap akaun yang anda proses, program tersebut akan melaksanakan permintaan dan kemudian hanya menunggu respons sebelum memulakan yang seterusnya.

Jadi jika anda menanda tiga pengguna seperti api.github.com/users/python, api.github.com/users/google and api.github.com/users/firebase, kod tersebut menghantar permintaan pertama, menyekat sehingga GitHub membalas, kemudian beralih ke permintaan kedua, dan begitulah seterusnya. Dengan segelintir pengguna, ini mungkin boleh diterima, tetapi apabila senarai anda berkembang menjadi ratusan atau ribuan, jumlah masa pemprosesan akan meningkat, kerana aplikasi anda menghabiskan sebahagian besar jangka hayatnya terbiar, menunggu pelayan jauh.

Untuk mempercepatkan proses, anda boleh beralih kepada pelaksanaan tak segerak yang dibina di atas asyncio dan klien HTTP yang berkemampuan asinkron seperti aiohttp. Dalam model itu, anda melancarkan beberapa tugasan coroutine yang semuanya menjalankan permintaan HTTP mereka hampir serentak. Gelung peristiwa kemudian menunggu respons daripada mana-mana daripadanya, menyambung semula setiap tugasan apabila data tiba, dan bukannya menunggu satu permintaan selesai sepenuhnya sebelum memulakan yang seterusnya.

Apabila anda menanda aras kedua-dua pendekatan ini secara bersebelahan, versi asinkron biasanya menang dengan margin yang besar, terutamanya apabila bilangan pengguna meningkat. Masa setiap permintaan tidak berubah, tetapi jumlah masa untuk mendapatkan semua keputusan menurun mendadak kerana anda mengendalikan banyak sambungan secara serentak dan bukannya secara bersiri.

Konsep Teras: Coroutine, Gelung Peristiwa, Tugas dan Masa Depan

Di sebalik hud, Python tak segerak moden berkisar tentang beberapa blok binaan utama yang disediakan terutamanya oleh asyncio modul. Memahami konsep-konsep ini akan menjadikan seluruh ekosistem kurang misteri dan membantu anda mereka bentuk seni bina asinkron yang mantap.

Coroutine ialah sejenis fungsi khas yang boleh menjeda dan menyambung semula pelaksanaannya sendiri. Dalam sintaks hari ini, anda mentakrifkan satu dengan async defApabila anda memanggilnya, anda akan mendapat objek coroutine yang perlu ditunggu atau dijadualkan; ia tidak berjalan sehingga siap serta-merta seperti fungsi biasa. Di dalamnya, setiap kali anda menggunakan await pada sesuatu yang boleh ditunggu (coroutine lain, tugas, masa depan, dll.), Python menggantung coroutine tersebut sehingga operasi yang ditunggu selesai.

Gelung peristiwa ialah orkestrator yang menjejaki semua coroutine, operasi I/O dan pemasa yang belum selesai, dan memutuskan bahagian kod mana yang berjalan pada bila-bila masa. Dari segi sejarah, anda perlu mendapatkan dan mengurus gelung secara eksplisit melalui asyncio.get_event_loop(), tetapi dalam kod Python moden, corak yang diutamakan adalah membiarkan asyncio.run() cipta, jalankan dan tutup gelung untuk anda di sekitar fungsi asinkron peringkat atasan seperti main().

Tugasan ialah pembalut di sekeliling coroutine yang memberitahu gelung peristiwa untuk menjadualkannya untuk pelaksanaan. Anda boleh menganggapnya sebagai kerja ringan: gelung boleh menyelang-seli kemajuan antara banyak tugas tanpa memutar berbilang thread. Anda biasanya mencipta tugas dengan asyncio.create_task() atau dengan menghubungi pembantu seperti asyncio.gather(), yang mengurus koleksi tugasan secara dalaman.

Niaga hadapan mewakili keputusan yang akan tersedia kemudian, sama seperti Janji dalam JavaScript. Kedua-dua tugas dan masa depan adalah objek yang dinanti-nantikan: anda boleh await mereka untuk menggantung sehingga operasi asas selesai. Protokol bersatu ini menjadikan kod orkestrasi lebih mudah, kerana penggubahan aliran asinkron bermuara pada menunggu objek yang betul dalam susunan yang betul.

Sintaks Async dalam Amalan: async, await, async with and async for

. async Kata kunci tidak terhad kepada definisi fungsi; ia juga meliputi pengurus konteks dan gelung supaya corak yang lebih maju boleh menyertai dunia asinkron. Mengetahui sintaks lanjutan ini membantu anda menulis kod yang elegan di sekitar sambungan rangkaian, sesi, strim dan protokol tersuai.

Bentuk yang paling biasa ialah async def, yang mentakrifkan fungsi tak segerak (kilang coroutine). Di dalam fungsi sedemikian, anda akan menggunakan dengan meluas await bila-bila masa anda memanggil coroutine lain atau operasi yang boleh ditunggu-tunggu, seperti asyncio.sleep(), permintaan HTTP tak segerak atau pertanyaan pangkalan data tak segerak. Ambil perhatian bahawa anda tidak boleh menggunakan await terus di peringkat atas skrip; ia mesti berada di dalam async def.

Walaupun anda mungkin tergoda untuk menghubungi time.sleep() di dalam coroutine anda untuk kelewatan, itu akan menggagalkan sepenuhnya tujuan penggunaan async. time.sleep() menyekat keseluruhan thread, termasuk gelung peristiwa, jadi tiada tugasan asinkron lain boleh berjalan dalam tempoh tersebut. Sebaliknya, anda mesti menggunakan rakan sejawat yang tidak menyekat asyncio.sleep(), yang menghasilkan kawalan kembali ke gelung semasa pemasa mengira detik.

Python juga menyokong pengurus konteks tak segerak melalui async with, dilaksanakan dengan menentukan kaedah khas __aenter__ and __aexit__. Ini amat berguna terutamanya apabila bekerja dengan objek yang memerlukan persediaan yang bersih dan urutan pembongkaran yang melibatkan operasi tak segerak, seperti membuka sesi rangkaian atau memperoleh sumber tak segerak. Contoh biasa ialah mengurus aiohttp.ClientSession atau permintaan HTTP individu menggunakan async with blok dan bukannya memanggil secara manual close().

Akhirnya, lelaran tak segerak didedahkan melalui async for, yang bergantung pada kaedah sihir __aiter__ and __anext__ diterangkan dalam PEP 492. Iterator asinkron dan penjana asinkron membolehkan anda menghasilkan item dari semasa ke semasa menggunakan await di dalam proses lelaran, yang sesuai untuk penstriman data yang tiba secara beransur-ansur melalui rangkaian atau daripada sumber asinkron yang lain.

Menjalankan Pelbagai Tugas Serentak dengan asyncio

Kuasa sebenar pengaturcaraan tak segerak muncul apabila anda menjalankan beberapa tugas terikat I/O secara serentak dan bukannya satu demi satu. Dalam ekosistem asinkron Python, alat utama untuk itu ialah asyncio.create_task() and asyncio.gather(), kedua-duanya menjadualkan coroutin pada gelung acara.

Dengan asyncio.gather(), anda boleh memulakan berbilang coroutine sekaligus dan menunggu sehingga semuanya selesai, menerima hasilnya sebagai senarai atau tuple. Ini sangat biasa berlaku dengan kumpulan panggilan HTTP, pertanyaan pangkalan data atau sebarang operasi tak segerak berulang. Di sebalik itu, gather() membungkus setiap coroutine ke dalam satu tugasan dan memastikan semuanya berjaya disiapkan.

Jika anda kembali kepada contoh mengambil profil GitHub tetapi memfaktorkannya semula menggunakan aiohttp and asyncio.gather(), anda akan mendapat tiga panggilan ke fungsi seperti fetch_user() dilancarkan serentak. Setiap tugasan memulakan permintaan HTTPnya, menghasilkan kawalan semasa menunggu data, dan kemudian menyambung semula penghuraian respons apabila ia tiba. Dari perspektif pengguna, ketiga-tiga hasil dipaparkan secara kasar pada masa yang sama.

Walau bagaimanapun, terdapat kes di mana anda tidak mahu menjalankan beribu-ribu atau berjuta-juta tugasan sekaligus, kerana itu boleh membebankan mesin anda sendiri atau mencapai had kadar luaran. Corak biasa adalah untuk mengehadkan keserentakan dengan pemprosesan sahaja MAX_TASKS operasi pada satu masa, sama ada menggunakan semafor, kolam terbatas atau logik pengelompokan manual dalam aliran kerja asinkron anda.

Satu lagi aspek penting apabila menjalankan banyak tugas secara serentak ialah cara anda mengendalikan ralat; membiarkan satu permintaan yang gagal merosakkan keseluruhan kelompok jarang sekali boleh diterima dalam aplikasi sebenar. Sebaik-baiknya, orkestrasi async anda harus menangkap dan mengurus pengecualian setiap tugas, mungkin mencatatnya, mencuba semula secara selektif atau mengembalikan hasil separa sambil mengekalkan baki kelompok yang utuh.

Mengendalikan Keserentakan: Manfaat dan Perangkap

Adalah penting untuk memisahkan idea-idea keserentakan dan paralelisme dalam fikiran anda, kerana Python async memberikan yang pertama tetapi tidak semestinya yang kedua. Keserentakan bermaksud pelbagai tugasan membuat kemajuan dalam selang masa yang bertindih, manakala paralelisme membayangkan ia secara literal berjalan pada masa yang sama pada berbilang teras CPU.

Kod tak segerak tipikal yang menggunakan asyncio tidak mencipta berbilang thread OS; sebaliknya, ia menggandakan tugas dalam satu thread mengikut bila setiap satu disekat pada I/O, sama seperti program asíncrona en Node.js. Itulah sebabnya ia berskala dengan begitu baik dengan beribu-ribu sambungan: penukaran konteks adalah murah kerana ia bersifat koperatif dan dikawal oleh gelung peristiwa dan bukannya sistem pengendalian.

Reka bentuk ini datang dengan cabaran, terutamanya berkaitan koordinasi dan pengendalian pengecualian. Oleh kerana logik anda kini tersebar merentasi beberapa coroutine yang saling berkaitan dalam masa, anda mesti lebih berhati-hati semasa berkongsi keadaan, menyebarkan ralat dan membersihkan sumber. Pepijat seperti dilupakan await, tugasan yang tidak pernah ditunggu-tunggu atau pengecualian yang ditelan senyap di latar belakang tugasan boleh menjadi halus dan sukar untuk didebug.

Untuk memastikan asas kod async anda dapat dikekalkan, anda harus mengikuti amalan kejuruteraan yang kukuh: pastikan coroutine tertumpu pada satu tanggungjawab, pusatkan pengendalian ralat jika boleh dan tambahkan pembalakan yang mencukupi untuk memahami apa yang berlaku semasa masa jalan. Alatan yang baik dan konvensyen yang jelas banyak membantu dalam mencegah isu seperti keadaan perlumbaan atau kebocoran sumber, walaupun dalam persekitaran asinkron berulir tunggal.

Bila Kod Asynchronous Benar-benar Membantu (dan Bila Ia Tidak)

Pengaturcaraan tak segerak sangat berkesan untuk beban kerja terikat I/O, tetapi ia bukanlah penyelesaian terbaik untuk setiap masalah prestasi. Langkah pertama dalam sebarang usaha pengoptimuman adalah untuk mengenal pasti sama ada kesesakan anda datang daripada I/O atau daripada pengiraan yang terikat dengan CPU.

Jika aplikasi anda menghabiskan sebahagian besar masanya menunggu respons rangkaian, membaca dan menulis fail, membuat pertanyaan pangkalan data atau berkomunikasi melalui soket, maka async hampir pasti sesuai. Contoh biasa termasuk API web yang berkomunikasi dengan pelbagai perkhidmatan luaran, saluran paip ETL yang membaca dan menulis kepada beberapa sumber data secara serentak dan perkhidmatan mikro yang menyelenggara banyak sambungan klien serentak.

Sebaliknya, jika beban kerja anda didominasi oleh operasi CPU yang berat seperti pengiraan nombor, pemprosesan imej atau simulasi yang kompleks, asinkron sahaja tidak akan mempercepatkan proses. Dalam senario sedemikian, GIL (Global Interpreter Lock) masih mengehadkan apa yang boleh berjalan secara selari dalam satu proses Python. Anda biasanya akan mendapat hasil yang lebih baik dengan pemprosesan berbilang, sambungan asli atau memanfaatkan hujung belakang khusus.

Dalam persekitaran korporat, strategi pragmatik adalah dengan menggabungkan teknik-teknik ini: menggunakan SDK asyncio dan async-aware untuk perkhidmatan awan (AWS, Azure dan lain-lain) bagi meminimumkan kependaman dan memaksimumkan daya pemprosesan, sambil mewakilkan kerja intensif CPU untuk memisahkan proses, pekerja atau perkhidmatan pengkomputeran terurus. Dengan cara itu, anda mengeksploitasi kekuatan setiap alat dan bukannya melawan runtime bahasa.

Amalan Terbaik untuk Menulis Python Async

Sebaik sahaja anda mula menerima pakai asinkron secara lebih meluas, corak dan tabiat tertentu akan membantu anda mengelakkan perangkap yang paling biasa. Ia juga menjadikan kod anda lebih jelas untuk rakan sepasukan yang mungkin belum begitu biasa dengan ekosistem asinkron.

Peraturan asas adalah untuk mengelakkan menyekat panggilan dalam laluan kod tak segerak anda. Ini bermakna menggantikan perkara seperti time.sleep() bersama await asyncio.sleep(), dan berhati-hati dengan pustaka yang tidak menawarkan API yang serasi dengan asinkron. Jika pakej pihak ketiga adalah segerak semata-mata, memanggilnya secara meluas daripada coroutine boleh menyekat gelung peristiwa dan merosakkan faedah keserentakan anda.

Apabila anda mempunyai sekumpulan operasi I/O bebas, lebih baik jalankannya secara serentak menggunakan utiliti seperti asyncio.gather() atau himpunan tugasan yang dikekang oleh tahap keserentakan maksimum. Corak ini meningkatkan daya pemprosesan sambil mengekalkan kawalan ke atas bilangan sambungan terbuka atau permintaan dalam penerbangan.

Sebagai garis panduan reka bentuk, cuba pastikan coroutine agak kecil dan tertumpu pada tanggungjawab yang jelas, sama seperti cara anda mereka bentuk fungsi dalam kod segerak yang bersih. Coroutine monolitik besar yang menggabungkan rangkaian, logik perniagaan dan pengendalian ralat dengan cepat menjadi sukar untuk diuji dan dipertimbangkan, terutamanya apabila sesuatu gagal di pertengahan jalan.

Akhir sekali, sentiasa semak sama ada komponen ekosistem yang anda andalkan benar-benar menyokong penggunaan tak segerak. Banyak pustaka popular menyediakan klien asinkron berasingan atau submodul khusus; yang lain mungkin masih menyekat secara rahsia walaupun mereka mengiklankan ciri "asikron". Membaca dokumentasi dengan teliti dan melakukan penanda aras kecil boleh menyelamatkan anda daripada regresi prestasi yang halus.

Senario Penggunaan Praktikal dan Idea Seni Bina

Dalam projek perisian dunia sebenar, async menyerlah dalam pelbagai seni bina, daripada bahagian belakang web tradisional hinggalah sistem berkuasa AI yang canggih. Elemen penyatuan sentiasa merupakan keperluan untuk mengendalikan banyak operasi terikat I/O tanpa membuang masa untuk menunggu secara terbiar.

Satu senario klasik ialah perkhidmatan web yang perlu memanggil beberapa API luaran untuk membina satu respons untuk klien. Menggunakan async, perkhidmatan ini boleh mencetuskan semua permintaan keluar sekaligus dan memasang muatan akhir sebaik sahaja setiap bahagian tiba, sekali gus mengurangkan jumlah masa tindak balas dengan ketara. Ini adalah perkara biasa dalam seni bina mikroservis dan integrasi dengan gerbang pembayaran, rangkaian sosial atau platform analitik.

Satu lagi kes penggunaan penting ialah kejuruteraan data: saluran paip dan kerja ETL kerap berinteraksi dengan berbilang pangkalan data, sistem fail atau baldi storan awan secara selari. Dengan membaca daripada beberapa sumber secara serentak dan menulis hasil sebaik sahaja ia siap, anda mengurangkan kependaman keseluruhan dan menggunakan lebar jalur yang tersedia dengan lebih baik, terutamanya apabila bekerja dengan storan awan atau API data berasaskan REST.

Async juga berfungsi dengan baik dengan papan pemuka dan alat perisikan perniagaan seperti Power BI, di mana backend mesti mengagregatkan data daripada perkhidmatan yang berbeza tanpa menyekat sambungan HTTP yang berjalan lama. Membina lapisan API tersuai anda atau perkhidmatan mikro integrasi dengan asyncio boleh meningkatkan daya tindak balas dan daya pemprosesan yang dirasakan di bawah beban.

Syarikat yang pakar dalam perisian tersuai, kecerdasan buatan, keselamatan siber dan perundingan awan sering bergantung pada teknik asinkron untuk mengatur aliran kerja yang memanggil model AI, mencatat peristiwa, memantau ancaman dan bercakap dengan pesawat kawalan awan. Menggabungkan I/O asinkron untuk orkestrasi dengan pekerja yang dioptimumkan CPU berasingan untuk kerja-kerja berat ialah corak dalaman biasa yang menghasilkan sistem yang boleh diskala dan diselenggara.

Bagi kebanyakan pembangun dan pasukan, langkah pertama hanyalah memperkenalkan async ke dalam bahagian aplikasi yang jelas menjerit "terikat I/O", kemudian berulang dari situ apabila manfaatnya menjadi jelas dan pasukan memperoleh keyakinan dengan paradigma dan perkakasan.

Akhirnya, pengaturcaraan tak segerak dalam Python adalah tentang penggunaan masa menunggu dengan bijak: dengan menstrukturkan kod anda di sekitar async, await, coroutine dan gelung peristiwa, anda boleh membina aplikasi yang terasa lebih pantas, berskala lebih baik di bawah beban dan memanfaatkan sepenuhnya sumber yang tersedia, terutamanya apabila berurusan dengan rangkaian, fail dan perkhidmatan luaran.