Async Python: Kapan Benar-benar Berguna

Ada kesalahpahaman yang sangat umum: menambahkan async membuat kode jadi lebih cepat. Tidak begitu cara kerjanya.

Yang sebenarnya dilakukan async

Async tidak membuat satu tugas selesai lebih cepat. Async membuat programmu bisa mengerjakan hal lain sambil menunggu.

Kalau programmu menghabiskan waktu menghitung, async tidak menolong sama sekali — malah menambah beban. Kalau programmu menghabiskan waktu menunggu, async bisa mengubah segalanya.

Bedanya menunggu dan menghitung

Menunggu (async menolong): panggilan API, query database, baca-tulis file, permintaan HTTP.

Menghitung (async tidak menolong): mengolah gambar, kalkulasi berat, parsing data besar, kompresi.

Contoh yang membuatnya jelas

Memanggil lima API secara berurutan:

import httpx, time

def ambil_semua(urls):
    hasil = []
    with httpx.Client() as client:
        for url in urls:
            hasil.append(client.get(url).json())
    return hasil

# 5 API × 2 detik = 10 detik

Versi async:

import asyncio, httpx

async def ambil_semua(urls):
    async with httpx.AsyncClient() as client:
        tugas = [client.get(url) for url in urls]
        respons = await asyncio.gather(*tugas)
    return [r.json() for r in respons]

# 5 API bersamaan = ~2 detik

Lima kali lebih cepat. Bukan karena Python jadi lebih kencang, tapi karena waktu tunggunya ditumpuk, bukan diantre.

Di Django

Django mendukung async view dan async ORM. Tapi jangan asal mengubah semua view jadi async.

# Berguna: view yang memanggil layanan eksternal
async def dashboard(request):
    cuaca, kurs, berita = await asyncio.gather(
        ambil_cuaca(),
        ambil_kurs(),
        ambil_berita(),
    )
    return render(request, "dashboard.html", {...})

# Tidak berguna: view yang cuma query database sederhana
async def daftar_produk(request):
    produk = [p async for p in Produk.objects.all()]
    return render(request, "produk.html", {"produk": produk})
    # Versi sync-nya sama cepat, dan lebih mudah dibaca

Jebakan paling berbahaya

Memanggil kode sync yang lambat di dalam fungsi async. Ini memblokir seluruh event loop — bukan cuma satu permintaan, tapi semua permintaan yang sedang ditangani proses itu.

# BAHAYA — memblokir semuanya
async def view(request):
    time.sleep(5)          # salah
    requests.get(url)      # salah, requests itu sync
    hasil = query_berat()  # salah

# BENAR
async def view(request):
    await asyncio.sleep(5)
    await httpx_client.get(url)
    hasil = await sync_to_async(query_berat)()

Kesimpulan sederhana

Pakai async kalau kode kamu banyak menunggu jaringan. Lewati kalau tidak. Kompleksitas tambahannya nyata, dan hanya sepadan kalau kamu benar-benar mendapat manfaatnya.