Asynchronous Programming Dalam Python

Pemrograman asinkron ialah paradigma pemrograman yang memungkinkan banyak proses bekerja secara bersamaan dan mandiri, tanpa Await satu proses selesai sebelum melanjutkan ke proses berikutnya. Dalam posting blog ini kita akan melihat apa itu pemrograman asinkron dan bagaimana menggunakannya dengan python.

Apa itu Pemrograman Asinkron?

Dalam pemrograman sinkron, computer mengeksekusi instruksi secara berurutan, memblokir eksekusi hingga suatu pekerjaan selesai saat sebelum melanjutkan ke pekerjaan selanjutnya.

Pemrograman asinkron, di sisi lain, memungkinkan program untuk memulai satu operasi dan melanjutkan ke operasi lain tanpa menghentikan eksekusi hingga tugas awal selesai.

Pemrograman asinkron sangat bermanfaat dalam keadaan di mana proses, seperti jaringan I/O atau operasi basis data, dapat memerlukan waktu lama untuk diselesaikan. Pemrograman asinkron bisa membantu meningkatkan kinerja dan daya tanggap dalam aplikasi perangkat lunak dengan membiarkan program melanjutkan ke aktivitas lain sambil Await operasi yang lambat selesai.

Tergantung pada bahasa pemrograman dan kerangka kerja yang digunakan, pemrograman asinkron bisa dilakukan menggunakan berbagai strategi seperti panggilan balik, janji, atau keyword async/Await.

Perbedaan Antara Pemrograman Asinkron dan Mutliprocessing

Perbedaan utama antara pemrograman asinkron dan multiprosesing ialah jika pemrograman asinkron memungkinkan operasi non-pemblokiran terjadi dalam satu utas, dan multiprosesing menggunakan banyak pokok atau proses untuk menyelesaikan pekerjaan secara bersamaan.

Perbedaan Antara Pemrograman Asinkron dan Threading

Perbedaan utama antara pemrograman asinkron dan threading ialah jika pemrograman asinkron memungkinkannya operasi tanpa pemblokiran dengan menggunakan satu utas, dan threading menggunakan banyak utas untuk melakukan banyak tugas secara paralel.

Bagaimana cara menggunakan Asyncio?

import time
import asyncio

def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    for job in todo:
        do_job(job)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

main()

# OUTPUT
# Job A started
# Job Adone
# Job B started
# Job B done
# Job C started
# Job C done
# Took: 3.009 seconds

Pertama mari kita buat program sederhana yang mulai melakukan pekerjaan pada satu waktu dan menyelesaikannya.

Untuk menggunakan pemrograman asinkron dengan Python, kita perlu menggunakan keyword async await dan pustaka asyncio.

Membuat dan Menjalankan Coroutine

Coroutine ialah jenis fungsi yang dapat diinterupsi dan dilanjutkan pada berbagai waktu selama eksekusi. Dengan kata lain, coroutine memungkinkan Anda untuk menulis code yang bisa diinterupsi, melakukan hal-hal lain, lalu melanjutkan dari bagian paling akhir.

Untuk membuat coroutine, kita perlu menggunakan keyword async saat sebelum keyword def. Memanggil coroutine tidak memanggil fungsi yang ingin kita jalankan. Itu menciptakan pekerjaan.

import time
import asyncio

async def do_job(s):
  ...

async def main():
  ...

main()

Maka sama seperti yang Anda lihat, menggunakan main() tidak menjalankannya. Untuk menjalankannya, kita perlu menggunakan asyncio.run(task). Kita mengetahui jika main() mengembalikan task yang ingin kita jalankan . Maka alihkan main() ke:

asyncio.run(main())

Await keyword

Jika Anda menjalankan code ini, Anda mungkin mendapatkan kesalahan semacam ini:

RuntimeWarning: coroutine '...' was never awaited

Bila Anda sebelumnya pernah melihat kesalahan ini, mungkin Anda lupa menggunakan fungsi ini dengan keyword await. Await berarti Await sampai ini selesai dan jeda pekerjaan saat ini. Anda perlu menjalankan tiap coroutine dengan keyword await.

import time
import asyncio

async def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

async def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    for job in todo:
        await do_job(job)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

asyncio.run(main())

# OUTPUT
# Job A started
# Job A done
# Job B started
# Job B done
# Job C started
# Job C done
# Took: 3.009 seconds

Sama seperti yang Anda lihat, kami tidak mendapatkan perbedaan apa pun itu. Itu karena kita menggunakan fungsi time.sleep(), yang menghentikan semua operasi pada code kita, kita perlu menggantinya dengan asyncio.sleep() yang disebut coroutine.

await asyncio.sleep(1)

Tetapi itu juga tidak mengubah apa pun itu . Jadi apa permasalahannya? Ingat apa arti keyword Await. Maknanya Await sampai tugas usai. Tetapi kami tidak mau Await tugas ini usai saat sebelum memulai tugas berikutnya. Kami ingin memulainya bersama dan Await sampai selesai. Kita dapat memperbaikinya dengan task "s" kita perlu beralih ke loop dengan:

tasks = [asyncio.create_task(do_job(item)) for item in todo]
done, pending = await asyncio.wait(tasks)

Kami menggunakan asyncio.create(task) untuk membuat tugas dari do_job coroutine dan kami mulai menjalankannya secara bersamaan.

import time
import asyncio

async def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

async def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    
    tasks = [asyncio.create_task(do_job(item)) for item in todo]
    done, pending = await asyncio.wait(tasks)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

asyncio.run(main())

# OUTPUT
# Job A started
# Job B started
# Job C started
# Job A done
# Job B done
# Job C done
# Took: 1.009 seconds