Asyncio: Sebuah Pengantar

Definisi

Modul asyncio menyediakan kerangka kerja yang berpusat pada event loop. Event loop pada dasarnya menunggu sesuatu terjadi lalu bertindak terhadap peristiwa tersebut. Ia bertanggung jawab menangani hal-hal seperti I/O dan event sistem.

asyncio sebenarnya memiliki beberapa implementasi loop yang tersedia. Modul ini akan menggunakan default yang paling efisien untuk sistem operasi tempat ia dijalankan; namun Anda juga dapat memilih event loop secara eksplisit jika diinginkan. Event loop pada dasarnya mengatakan “ketika peristiwa A terjadi, tanggapi dengan fungsi B”.

Bayangkan sebuah server yang menunggu seseorang datang dan meminta suatu sumber daya, seperti laman web. Jika situs webnya tidak terlalu populer, server akan menganggur cukup lama. Tetapi ketika ada permintaan, server perlu bereaksi. Reaksi ini dikenal sebagai penanganan peristiwa (event handling). Saat pengguna memuat laman web, server akan memeriksa dan memanggil satu atau lebih event handler. Setelah event handler selesai, mereka perlu mengembalikan kendali ke event loop. Untuk melakukan ini di Python, asyncio menggunakan coroutine.

Coroutine adalah fungsi khusus yang dapat menyerahkan kendali ke pemanggilnya tanpa kehilangan state-nya. Coroutine adalah konsumen dan perpanjangan dari generator. Salah satu keuntungan besar dibanding thread adalah coroutine tidak banyak menggunakan memori saat dieksekusi. Perhatikan bahwa ketika Anda memanggil fungsi coroutine, fungsinya tidak langsung dieksekusi. Alih-alih, ia akan mengembalikan objek coroutine yang dapat Anda teruskan ke event loop untuk dijalankan segera atau nanti.

Satu istilah lain yang mungkin akan Anda temui saat menggunakan modul asyncio adalah future. Future pada dasarnya adalah objek yang merepresentasikan hasil dari pekerjaan yang belum selesai. Event loop Anda dapat memantau objek future dan menunggu hingga selesai. Ketika future selesai, statusnya menjadi done. Asyncio juga mendukung lock dan semaphore.

Bagian terakhir yang ingin saya sebutkan adalah Task. Task adalah pembungkus untuk coroutine dan subkelas dari Future. Anda bahkan dapat menjadwalkan Task menggunakan event loop.

async dan await

Kata kunci async dan await ditambahkan di Python 3.5 untuk mendefinisikan coroutine native dan menjadikannya tipe yang berbeda dibanding coroutine berbasis generator. Jika Anda menginginkan penjelasan mendalam tentang async dan await, silakan baca PEP 492.

Pada Python 3.4, Anda akan membuat coroutine seperti ini:

Decorator ini masih berfungsi di Python 3.5, tetapi modul types menerima pembaruan berupa coroutine function yang kini dapat memberi tahu apakah yang Anda gunakan adalah coroutine native atau bukan. Mulai Python 3.5, Anda dapat menggunakan async def untuk secara sintaktis mendefinisikan fungsi coroutine.

Jadi fungsi di atas akan terlihat seperti ini:

Saat Anda mendefinisikan coroutine dengan cara ini, Anda tidak dapat menggunakan yield di dalam fungsi coroutine. Sebagai gantinya, fungsi harus menyertakan pernyataan return atau await yang digunakan untuk mengembalikan nilai ke pemanggil. Perhatikan bahwa kata kunci await hanya dapat digunakan di dalam fungsi async def.

Kata kunci async/await dapat dianggap sebagai API untuk pemrograman asinkron. Modul asyncio hanyalah kerangka kerja yang kebetulan menggunakan async/await untuk pemrograman asinkron. Sebenarnya ada proyek bernama curio yang membuktikan konsep ini karena merupakan implementasi event loop terpisah yang menggunakan async/await di balik layar.

Contoh Coroutine yang Buruk

Walaupun tentu membantu memiliki banyak informasi latar tentang cara kerja semua ini, terkadang Anda hanya ingin melihat beberapa contoh agar bisa merasakan sintaksnya dan cara menyusunnya.

Dengan pemikiran itu, mari mulai dengan contoh sederhana!

Salah satu tugas yang cukup umum adalah mengunduh berkas dari suatu lokasi, baik itu sumber internal maupun berkas di Internet. Biasanya Anda ingin mengunduh lebih dari satu berkas.

Jadi mari kita buat sepasang coroutine yang bisa melakukan itu:

import asyncio
import os
import urllib.request
 
async def download_coroutine(url):
    #"A coroutine to download the specified url"
    request = urllib.request.urlopen(url)
    filename = os.path.basename(url)
 
    with open(filename, 'wb') as file_handle:
        while True:
            chunk = request.read(1024)
            if not chunk:
                break
            file_handle.write(chunk)
    msg = 'Finished downloading {filename}'.format(filename=filename)
    return msg
 
async def main(urls):
    """
    Creates a group of coroutines and waits for them to finish
    """
    coroutines = [download_coroutine(url) for url in urls]
    completed, pending = await asyncio.wait(coroutines)
    for item in completed:
        print(item.result())
 
 
if __name__ == '__main__':
    urls = ["http://www.irs.gov/pub/irs-pdf/f1040.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040a.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040ez.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040es.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040sb.pdf"]
 
    event_loop = asyncio.get_event_loop()
    try:
        event_loop.run_until_complete(main(urls))
    finally:
        event_loop.close()

Pada kode ini, kita mengimpor modul yang diperlukan lalu membuat coroutine pertama menggunakan sintaks async. Coroutine ini bernama download_coroutine dan menggunakan urllib milik Python untuk mengunduh URL apa pun yang diteruskan kepadanya. Ketika selesai, ia akan mengembalikan pesan yang menyatakan hal tersebut.

Coroutine lainnya adalah coroutine utama kita. Ia pada dasarnya menerima daftar satu atau lebih URL dan mengantrikannya. Kita menggunakan fungsi wait milik asyncio untuk menunggu coroutine-coroutine tersebut selesai. Tentu saja, untuk benar-benar memulai coroutine, mereka perlu ditambahkan ke event loop. Kita melakukannya di bagian akhir saat kita mendapatkan event loop dan memanggil metode run_until_complete-nya. Anda akan melihat bahwa kita meneruskan coroutine utama ke event loop. Ini akan menjalankan coroutine utama yang mengantri coroutine kedua dan memulainya. Ini dikenal sebagai chained coroutine.

Masalah dengan contoh ini adalah sebenarnya ini bukan coroutine sama sekali. Alasannya adalah fungsi download_coroutine tidak bersifat asinkron. Permasalahannya adalah urllib tidak asinkron dan selain itu, saya tidak menggunakan await atau yield sama sekali. Cara yang lebih baik adalah menggunakan paket aiohttp. Mari kita lihat itu selanjutnya!

Contoh Coroutine yang Lebih Baik

Paket aiohttp dirancang untuk membuat klien dan server HTTP asinkron. Anda dapat memasangnya dengan pip seperti ini:

pip install aiohttp

Setelah terpasang, mari perbarui kode kita untuk menggunakan aiohttp sehingga kita dapat mengunduh berkas-berkas tersebut:

Anda akan melihat di sini bahwa kita mengimpor dua hal baru: aiohttp dan async_timeout. Yang terakhir sebenarnya adalah salah satu dependensi aiohttp dan memungkinkan kita membuat context manager timeout. Mari mulai dari bagian bawah kode dan bergerak ke atas. Pada pernyataan kondisional paling bawah, kita memulai event loop asinkron dan memanggil fungsi main kita.

Di fungsi main, kita membuat objek ClientSession yang kita teruskan ke fungsi coroutine pengunduhan untuk setiap url yang ingin kita unduh. Di download_coroutine, kita membuat context manager async_timeout.timeout() yang pada dasarnya membuat penghitung waktu dalam detik. Ketika waktunya habis, context manager berakhir atau timeout. Dalam kasus ini, timeout-nya 10 detik. Berikutnya kita memanggil metode get() milik session yang memberi kita objek response. Sekarang kita sampai pada bagian yang agak “ajaib”. Saat Anda menggunakan atribut content dari objek response, ia mengembalikan instance aiohttp.StreamReader yang memungkinkan kita mengunduh berkas secara bertahap (chunk) dengan ukuran yang kita inginkan. Saat kita membaca berkas, kita menuliskannya ke disk lokal. Terakhir, kita memanggil metode release() milik response, yang akan menyelesaikan pemrosesan response.

Menurut dokumentasi aiohttp, karena objek response dibuat di dalam context manager, secara teknis ia memanggil release() secara implisit. Namun dalam Python, eksplisit biasanya lebih baik dan ada catatan di dokumentasi bahwa kita tidak boleh bergantung pada koneksi yang “otomatis hilang”, jadi saya rasa lebih baik tetap memanggil release dalam kasus ini.

Masih ada satu bagian yang memblokir di sini, yaitu bagian kode yang benar-benar menulis ke disk. Saat kita menulis berkas, kita tetap memblokir. Ada pustaka lain bernama aiofiles yang bisa kita gunakan untuk mencoba membuat proses penulisan berkas menjadi asinkron juga, namun pembaruan itu saya serahkan kepada pembaca.

Menjadwalkan Pemanggilan

Anda juga dapat menjadwalkan pemanggilan ke fungsi reguler menggunakan event loop asyncio. Metode pertama yang akan kita lihat adalah call_soon. Metode call_soon pada dasarnya akan memanggil callback atau event handler Anda secepat yang bisa dilakukan. Ini bekerja sebagai antrean FIFO, jadi jika beberapa callback membutuhkan waktu lama untuk berjalan, maka yang lain akan tertunda sampai yang sebelumnya selesai.

Mari lihat contohnya:

Mayoritas fungsi asyncio tidak menerima argumen keyword, sehingga kita membutuhkan modul functools jika perlu meneruskan keyword ke event handler kita. Fungsi reguler kita akan mencetak teks ke stdout setiap kali dipanggil. Jika Anda mengatur argumen stop-nya ke True, fungsi ini juga akan menghentikan event loop.

Pemanggilan pertama tidak menghentikan loop. Pemanggilan kedua menghentikan loop. Alasannya karena kita telah memerintahkan loop untuk run_forever, yang akan menempatkan event loop dalam loop tak terbatas. Setelah loop dihentikan, kita dapat menutupnya.

Jika Anda menjalankan kode ini, Anda akan melihat keluaran berikut:

starting event loop
Event handler called
Event handler called
stopping the loop
closing event loop

Ada fungsi terkait bernama call_soon_threadsafe. Sesuai namanya, ia bekerja sama seperti call_soon, tetapi thread-safe. Jika Anda ingin benar-benar menunda pemanggilan hingga waktu tertentu di masa depan, Anda dapat menggunakan fungsi call_later. Dalam kasus ini, kita bisa mengubah pemanggilan call_soon menjadi sebagai berikut:

loop.call_later(1, event_handler, loop)

Ini akan menunda pemanggilan event handler selama satu detik, kemudian memanggilnya dan meneruskan loop sebagai parameter pertamanya. Jika Anda ingin menjadwalkan waktu spesifik di masa mendatang, maka Anda perlu mengambil waktu milik loop, bukan waktu komputer. Anda bisa melakukannya seperti ini:

current_time = loop.time()

Setelah itu, Anda bisa menggunakan fungsi call_at dan meneruskan waktu kapan Anda ingin memanggil event handler. Misalnya kita ingin memanggil event handler lima menit dari sekarang. Berikut cara melakukannya:

loop.call_at(current_time + 300, event_handler, loop)

Pada contoh ini, kita menggunakan waktu saat ini yang telah diambil dan menambahkan 300 detik atau lima menit. Dengan begitu, kita menunda pemanggilan event handler selama lima menit! Cukup keren!

Tugas (Tasks)

Task adalah subkelas dari Future dan pembungkus untuk coroutine. Task memberi Anda kemampuan untuk melacak kapan pemrosesan selesai. Karena merupakan tipe Future, coroutine lain dapat menunggu sebuah task dan Anda juga dapat mengambil hasil task saat pemrosesannya selesai.

Mari kita lihat contoh sederhana:

Di sini kita membuat fungsi asinkron yang menerima jumlah detik yang dibutuhkan fungsi untuk berjalan. Ini mensimulasikan proses yang berjalan lama. Lalu kita membuat event loop dan membuat objek task dengan memanggil fungsi create_task milik objek event loop. Fungsi create_task menerima fungsi yang ingin kita ubah menjadi task. Kemudian kita memberi tahu event loop untuk berjalan hingga task selesai. Pada bagian akhir, kita mengambil hasil task karena sudah selesai.

Task juga dapat dibatalkan dengan sangat mudah menggunakan metode cancel. Cukup panggil saat Anda ingin mengakhiri task. Jika sebuah task dibatalkan ketika menunggu operasi lain, task tersebut akan memunculkan CancelledError.

Penutup

Pada titik ini, Anda seharusnya sudah cukup paham untuk mulai bekerja dengan pustaka asyncio secara mandiri. Pustaka asyncio sangat kuat dan memungkinkan Anda melakukan banyak tugas yang menarik. Pustaka asyncio dirancang untuk soket jaringan.

Pustaka hebat yang memungkinkan pemrograman soket asinkron sebelum asyncio adalah kerangka kerja Twisted. Proyek menarik lainnya adalah Dask, yang merupakan pustaka komputasi paralel yang fleksibel untuk komputasi analitik. Telusuri dokumentasi modul asyncio dan biarkan ide-ide Anda mengalir!