0Pricing
Python Academy · Pelajaran

Pola I/O Asinkron dalam Produksi

Terapkan asyncio pada klien HTTP, antrean, dan pipeline dunia nyata.

Pola I/O Asinkron dalam Produksi adalah pelajaran Python Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Python Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Python Academy mencakup 4 pelajaran total.

Praktik Terbaik Perulangan Peristiwa

Selalu gunakan asyncio.run() sebagai satu-satunya titik masuk. Hindari mencampur kode sinkron dan asinkron secara sembarangan, dan jangan pernah memblokir perulangan peristiwa dengan pekerjaan CPU yang lama.

import asyncio

async def main():
    # Never: time.sleep() — blocks the event loop
    # Always: await asyncio.sleep()
    await asyncio.sleep(1)

asyncio.run(main())

Pengelolaan Kumpulan Koneksi

Gunakan kembali koneksi, alih-alih membuka koneksi baru untuk setiap permintaan. Pustaka seperti asyncpg dan aiohttp menyediakan kumpulan koneksi bawaan.

# pip install asyncpg
import asyncpg, asyncio

async def main():
    pool = await asyncpg.create_pool(
        dsn="postgresql://user:pass@host/db",
        min_size=5, max_size=20
    )
    async with pool.acquire() as conn:
        row = await conn.fetchrow("SELECT 1")
    await pool.close()

Produsen-Konsumen dengan asyncio.Queue

asyncio.Queue memisahkan produsen dan konsumen yang berjalan sebagai tugas bersamaan.

import asyncio

async def producer(q):
    for i in range(5):
        await q.put(i)
        await asyncio.sleep(0.5)
    await q.put(None)  # sentinel

async def consumer(q):
    while (item := await q.get()) is not None:
        print(f"processing {item}")
        q.task_done()

async def main():
    q = asyncio.Queue()
    await asyncio.gather(producer(q), consumer(q))

asyncio.run(main())

Pembatasan Laju dengan Semaphore

Batasi permintaan keluar yang berjalan bersamaan agar tidak membebani API eksternal atau mencapai batas laju.

import asyncio, aiohttp

SEM = asyncio.Semaphore(10)  # 10 concurrent requests max

async def fetch(session, url):
    async with SEM:
        async with session.get(url) as r:
            return await r.json()

async def main(urls):
    async with aiohttp.ClientSession() as s:
        return await asyncio.gather(*[fetch(s, u) for u in urls])

Percobaan Ulang dengan Jeda Mundur Eksponensial

Bungkus operasi yang dapat dicoba ulang dengan logika jeda mundur untuk menangani kegagalan sementara dengan baik.

import asyncio

async def retry(coro_fn, retries=3, base=1):
    for attempt in range(retries):
        try:
            return await coro_fn()
        except Exception as e:
            if attempt == retries - 1: raise
            delay = base * 2 ** attempt
            await asyncio.sleep(delay)

Penghentian Mulus

Tangkap asyncio.CancelledError dalam tugas yang berjalan lama dan tangani sinyal OS agar penghentian berlangsung dengan bersih.

import asyncio, signal

async def server():
    stop = asyncio.Event()
    loop = asyncio.get_running_loop()
    loop.add_signal_handler(signal.SIGINT, stop.set)
    await stop.wait()
    print("Shutting down gracefully")

Pengaliran Respons

Gunakan generator asinkron untuk mengalirkan respons besar tanpa memuatnya seluruhnya ke memori.

import asyncio, aiohttp

async def stream(url):
    async with aiohttp.ClientSession() as s:
        async with s.get(url) as r:
            async for chunk in r.content.iter_chunked(4096):
                process(chunk)

async def process(chunk):
    await asyncio.sleep(0)
    print(len(chunk), "bytes")

Tugas Latar Belakang di FastAPI

FastAPI menggunakan BackgroundTasks untuk mengantrikan pekerjaan yang dijalankan setelah respons dikirim, sehingga titik akhir tetap cepat.

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def send_email(to: str, body: str):
    # heavy synchronous work
    pass

@app.post("/register")
async def register(email: str, bg: BackgroundTasks):
    bg.add_task(send_email, email, "Welcome!")
    return {"status": "registered"}

Pola Denyut Jantung

Jalankan tugas latar belakang berkala bersamaan dengan perulangan server utama menggunakan create_task.

import asyncio

async def heartbeat():
    while True:
        print("alive")
        await asyncio.sleep(30)

async def main():
    asyncio.create_task(heartbeat())
    await serve_forever()

Pemprofilan Kode Asinkron

Gunakan yappi atau py-spy untuk pemprofilan yang memahami kode asinkron. Aktifkan mode debug asyncio untuk mendapatkan peringatan tentang panggilan balik yang lambat.

# Enable debug to catch slow callbacks:
# asyncio.run(main(), debug=True)

# PYTHONASYNCIODEBUG=1 python server.py
# logs: Executing <Task coroutine=...> took 0.150 seconds

Menghindari Jebakan Umum

Aturan utama: jangan pernah memanggil kode yang memblokir pada perulangan peristiwa; selalu menunggu korutin; batalkan tugas saat penghentian; gunakan kumpulan koneksi; batasi konkurensi dengan semafor.

import asyncio

async def bad():
    import time
    time.sleep(2)        # blocks the entire event loop!

async def good():
    await asyncio.sleep(2)  # yields control

Pemeriksaan Singkat

Primitif asyncio apa yang memisahkan produsen dan konsumen yang berjalan sebagai tugas bersamaan?

Ringkasan

Pola asinkron untuk produksi: gunakan kumpulan koneksi, kendalikan konkurensi dengan Semaphore, terapkan percobaan ulang dan jeda mundur, alirkan data besar, lakukan penghentian mulus saat menerima sinyal, dan jalankan tugas berkala dengan create_task.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola I/O Asinkron dalam Produksi” gratis?

Ya — teks lengkap “Pola I/O Asinkron dalam Produksi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Python Academy, upgrade ke CoddyKit PRO. Kursus Python Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pola I/O Asinkron dalam Produksi”?

Terapkan asyncio pada klien HTTP, antrean, dan pipeline dunia nyata. Kamu berlatih Python Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Python Academy?

Tidak diperlukan pengalaman sebelumnya. Python Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pola I/O Asinkron dalam Produksi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Python Academy ini?

Ya. Setiap pelajaran Python Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Coroutine dan Event Loop
  2. await, Task, dan Pengumpulan
  3. Pengelola Konteks dan Iterator Asinkron
  4. Pola I/O Asinkron dalam Produksi
← Kembali ke Python Academy