Dasar concurrency
Mengerjakan beberapa hal sekaligus membuat program lebih cepat, sekaligus memunculkan jenis bug baru. Concurrency vs parallelism, kenapa menunggu adalah alasan paling umum memakai concurrency, async di Python dan JavaScript, race condition yang bisa direproduksi, lock, race detector Go, dan versi database dari bug yang sama.
Semua yang ada di seri ini sejauh ini berjalan selangkah demi selangkah: baris demi baris, pemanggilan demi pemanggilan. Sistem sungguhan jarang bekerja seperti itu. Web server menangani banyak request sekaligus. Sebuah halaman memuat sepuluh hal secara bersamaan. Proses checkout memanggil API pembayaran, API pengiriman, dan layanan email. Mengerjakan beberapa hal sekaligus membuat software lebih cepat dan responsif. Tapi itu juga memunculkan jenis bug yang tidak ada di kode yang berjalan langkah demi langkah, dan bug-bug itu termasuk yang paling sulit ditemukan.
Bagian ini membahas dasarnya: apa itu concurrency, kapan ia membantu, dan satu bug yang pasti dialami semua orang, yaitu race condition.
Concurrency bukan parallelism
Ceramah Rob Pike tentang Go membuat pembedaan yang menjadi titik awal kebanyakan penjelasan: “Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once.” Concurrency adalah soal menangani banyak hal sekaligus; parallelism adalah soal mengerjakan banyak hal sekaligus. Lebih formalnya, “concurrency is the composition of independently executing processes”, susunan dari proses-proses yang berjalan sendiri-sendiri, sedangkan parallelism adalah hal-hal yang benar-benar berjalan pada saat yang sama, di core CPU yang berbeda.
Seorang pelayan dengan sepuluh meja itu concurrent: mencatat pesanan di sini, mengantar minuman di sana, tidak pernah diam menunggu satu meja selesai makan. Sepuluh pelayan itu parallel. Concurrency bisa terjadi di satu core, dengan berganti-ganti tugas saat masing-masing sedang menunggu. Parallelism butuh beberapa core.
Sebagian besar waktu, Anda sedang menunggu
Alasan paling umum memakai concurrency di kode sehari-hari bukan komputasi berat. Alasannya adalah menunggu: jaringan, database, disk, API. Request ke payment gateway bisa makan 300 ms, dan selama itu CPU tidak mengerjakan apa-apa.
Tiga pemanggilan yang masing-masing sekitar satu detik, satu per satu dibandingkan dimulai bersamaan, dengan asyncio di Python, “a library to write concurrent code using the async/await syntax”:
async def fetch(name, seconds):
await asyncio.sleep(seconds) # stands in for a network call
return f"{name} done"
async def one_by_one():
return [await fetch("rates", 1), await fetch("stock", 1), await fetch("email", 1)]
async def together():
return await asyncio.gather(fetch("rates", 1), fetch("stock", 1), fetch("email", 1))
one by one 3.01 s ['rates done', 'stock done', 'email done']
together 1.00 s ['rates done', 'stock done', 'email done']
Pekerjaannya sama, waktunya sepertiga, di satu thread. Tidak ada yang berjalan paralel; programnya hanya tidak diam saat menunggu.
JavaScript bekerja dengan cara yang sama, dan begitulah browser serta Node menangani semuanya. Promise.all “takes an iterable of promises as input and returns a single Promise”, menerima kumpulan promise dan mengembalikan satu promise yang terpenuhi saat semuanya terpenuhi:
for (const n of ["rates", "stock", "email"]) await fetchFake(n, 1000); // one by one
const all = await Promise.all([fetchFake("rates", 1000), fetchFake("stock", 1000), fetchFake("email", 1000)]);
one by one 3.00 s
together 1.00 s [ 'rates done', 'stock done', 'email done' ]
Perhatikan tambahan dari MDN: promise gabungan itu “rejects when any of the input’s promises rejects”, gagal begitu salah satu promise gagal. Kalau satu pemanggilan gagal, Anda perlu memutuskan apa yang terjadi pada yang lain. Ini penanganan error dari bagian 13 lagi, sekarang dengan beberapa hal yang sedang berjalan.
Untuk pekerjaan yang berat di CPU, bukan menunggu (memproses gambar, perhitungan besar), Anda butuh parallelism sungguhan: beberapa proses, atau bahasa dan runtime yang menjalankan thread di beberapa core. Di CPython standar, “due to the Global Interpreter Lock, only one thread can execute Python code at once”, hanya satu thread yang bisa menjalankan kode Python pada satu waktu, meskipun “threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously”: thread tetap cocok untuk banyak tugas yang menunggu I/O. Python 3.13 menambahkan build free-threaded opsional yang menghapus batasan itu, tapi belum menjadi bawaan. Go, Java, dan bahasa lain menjalankan thread di banyak core tanpa pengaturan tambahan.
Race condition
Di sinilah mulai berbahaya. Stok buku tinggal satu, dan tiga pelanggan menekan “beli” pada saat yang sama. Setiap request berjalan di thread-nya sendiri:
stock = 1
sold = []
def buy(customer):
global stock
if stock >= 1: # check
time.sleep(0.01) # e.g. waiting for the payment API
stock -= 1 # act
sold.append(customer)
stock: -2 sold to: ['Ana', 'Budi', 'Cici']
Satu buku, tiga penjualan, dan stoknya minus. Ketiga thread mengecek stock >= 1 saat nilainya masih 1, lalu ketiganya menunggu, lalu ketiganya mengurangi. Itulah race condition: sistem “where the system’s substantive behavior is dependent on the sequence or timing of uncontrollable events”, seperti digambarkan Wikipedia, yaitu ketika perilaku sistem bergantung pada urutan atau waktu kejadian yang tidak bisa dikendalikan. Hasilnya tergantung siapa yang lebih dulu sampai.
Polanya disebut check-then-act: Anda mengecek sebuah kondisi, dan saat Anda bertindak, kondisi itu sudah tidak benar lagi. sleep di sini membuatnya terjadi setiap kali, tapi di kode sungguhan celahnya adalah apa pun yang terjadi di antara pengecekan dan tindakan: pemanggilan jaringan, bolak-balik ke database, atau sekadar penjadwal yang berganti thread. Tanpa sleep, kode ini akan lulus semua tes dan gagal sebulan sekali di production. Itulah heisenbug dari bagian 15.
Lock: satu per satu
Perbaikannya adalah membuat pengecekan dan tindakan terjadi sebagai satu langkah yang tidak bisa disela pihak lain. Lock (disebut juga mutex) hanya mengizinkan satu thread masuk ke sebuah blok kode pada satu waktu:
lock = threading.Lock()
def buy(customer):
global stock
with lock: # only one thread at a time in here
if stock >= 1:
time.sleep(0.01)
stock -= 1
sold.append(customer)
stock: 0 sold to: ['Ana']
Satu buku, satu penjualan. Lock punya ongkosnya sendiri: thread lain harus menunggu, jadi buat bagian yang dikunci sekecil mungkin. Dan dengan lebih dari satu lock, dua thread bisa masing-masing memegang satu lock dan saling menunggu selamanya. Itu deadlock, “any situation in which no member of some group of entities can proceed”, situasi saat tidak ada satu pun yang bisa melanjutkan. Aturan umumnya: selalu ambil lock dalam urutan yang sama, atau lebih baik lagi, cukup butuh satu lock.
Bahkan += 1 pun tidak aman
Race tidak butuh sleep atau if. Di Go, seribu goroutine masing-masing menambah satu ke sebuah penghitung:
visits := 0
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
visits++ // read, add, write: not atomic
}()
}
wg.Wait()
fmt.Println("visits:", visits)
Tiga kali dijalankan:
visits: 938
visits: 999
visits: 994
visits++ sebenarnya tiga langkah: baca nilainya, tambah satu, tulis kembali. Dua goroutine bisa membaca nilai yang sama, dan satu penambahan hilang. Jawabannya pun berbeda setiap kali dijalankan, dan justru itulah yang membuat bug seperti ini sulit ditangkap.
Go menyediakan alat untuk ini. Dokumentasinya: “Data races are among the most common and hardest to debug types of bugs in concurrent systems. A data race occurs when two goroutines access the same variable concurrently and at least one of the accesses is a write.” Data race termasuk bug paling umum dan paling sulit di-debug, dan terjadi saat dua goroutine mengakses variabel yang sama bersamaan dengan setidaknya satu menulis. Jalankan dengan -race:
==================
WARNING: DATA RACE
Read at 0x00c000112078 by goroutine 8:
main.main.func1()
main.go:15 +0x84
Previous write at 0x00c000112078 by goroutine 13:
main.main.func1()
main.go:15 +0x96
Alat itu menunjuk baris 15, visits++. Dengan sync.Mutex di sekitar penambahannya, race detector diam dan jawabannya visits: 1000 setiap kali. Go juga menyediakan sync/atomic untuk penghitung sederhana, dan channel untuk mengoper data antar-goroutine alih-alih berbagi data.
Bug yang sama di database Anda
Kode PHP biasanya tidak berbagi variabel antar-request: setiap request mendapat proses atau worker sendiri. Jadi mungkin Anda mengira race tidak berlaku. Tetap berlaku, satu tingkat di bawah: keadaan yang dibagi adalah database. Dua request membeli buku terakhir, disimulasikan dengan dua koneksi:
// Read-then-write: both requests read before either one writes.
$qtyA = $a->query("SELECT qty FROM stock WHERE product = 'book'")->fetchColumn();
$qtyB = $b->query("SELECT qty FROM stock WHERE product = 'book'")->fetchColumn();
if ($qtyA >= 1) { /* UPDATE stock SET qty = $qtyA - 1 */ }
if ($qtyB >= 1) { /* UPDATE stock SET qty = $qtyB - 1 */ }
A: sold
B: sold
stock now: 0
Dua penjualan untuk satu buku, dan kali ini stoknya bahkan terlihat wajar: keduanya menulis 0. Update yang hilang, tanpa error dan tanpa jejak. Perbaikannya adalah membiarkan database melakukan pengecekan dan perubahan dalam satu pernyataan atomik:
$sell = 'UPDATE stock SET qty = qty - 1 WHERE product = :p AND qty >= 1';
$stmt = $db->prepare($sell);
$stmt->execute(['p' => 'book']);
echo $stmt->rowCount() === 1 ? 'sold' : 'sold out';
A: sold
B: sold out
stock now: 0
WHERE qty >= 1 adalah pengecekannya, di dalam pernyataan yang sama dengan perubahannya. Kalau tidak ada baris yang ter-update, bukunya sudah habis. Alat lain untuk tugas yang sama: transaksi dengan SELECT ... FOR UPDATE di MySQL dan PostgreSQL untuk mengunci barisnya, unique constraint supaya database menolak duplikat, dan idempotency key dari bagian 20 untuk request yang terulang.
Kebiasaan yang menjaga concurrency tetap aman
- Sebisa mungkin jangan berbagi. Oper data masuk, kembalikan hasil keluar. Pure function (bagian 7) tidak punya race.
- Kalau harus berbagi, lindungi di satu tempat. Satu lock, satu pemilik, atau satu pernyataan database yang atomik.
- Waspadai check-then-act. “Kalau kosong, ambil”, “kalau belum ada, buat”, “kalau ada stok, jual”. Jadikan pengecekan dan tindakan satu operasi.
- Pakai alatnya.
-racedi Go, thread sanitizer di bahasa lain, dan load test yang mengirim banyak request sekaligus. - Pakai concurrency untuk menunggu lebih dulu. Menjalankan pemanggilan API yang independen secara bersamaan adalah kemenangan yang mudah dan bernilai tinggi. Pekerjaan CPU paralel adalah langkah yang lebih besar; ukur dulu sebelum mengambilnya (bagian 10).
Kenapa ini penting sehari-hari
- Setiap aplikasi web itu concurrent. Dua pengguna selalu bisa mengklik pada saat yang sama; submit ganda dan stok terjual melebihi jumlahnya adalah race condition.
- Kecepatan gratis. Pemanggilan API atau database yang independen dan dijalankan bersamaan sering memangkas waktu response setengahnya atau lebih.
- Bug yang bersembunyi. Race lolos dari tes dan muncul saat beban tinggi. Mengenali polanya adalah cara menemukannya saat review.
- Kode hasil AI sering memakai check-then-act (“cari, lalu buat”) dan keadaan bersama yang bisa berubah. Tanyakan: apa yang terjadi kalau dua request menjalankannya bersamaan?
Coba sendiri
- Jalankan contoh stok tanpa lock beberapa kali, lalu dengan lock. Coba hapus
sleep-nya: seberapa sering bug-nya masih muncul? - Jalankan penghitung Go dengan dan tanpa
-race, lalu perbaiki dengansync.Mutex, dan sekali lagi dengansync/atomic. - Cari “cek, lalu insert” di kode Anda (misalnya, “kalau belum ada user dengan email ini, buat”). Apa yang mencegah dua request sama-sama melakukan insert? Apakah unique constraint bisa membantu?
- Ambil halaman yang membuat beberapa pemanggilan API atau database yang independen, lalu jalankan secara bersamaan. Ukur bedanya.
Ringkasan
- Concurrency adalah menangani banyak hal sekaligus; parallelism adalah mengerjakannya pada saat yang sama.
- Kebanyakan concurrency sehari-hari adalah soal tidak diam saat menunggu:
asyncio.gather,Promise.all. - Race condition terjadi saat hasil bergantung pada waktu; check-then-act adalah bentuk klasiknya.
- Lock membuat sebuah blok berjalan satu per satu; buat sekecil mungkin dan hindari deadlock.
- Bahkan
x++pun tidak atomik; race detector Go menemukan data race. - Di aplikasi web, keadaan yang dibagi adalah database: pakai update bersyarat yang atomik, lock baris, dan constraint.
- Sebisa mungkin jangan berbagi; kalau harus, lindungi keadaan bersama di satu tempat.
Referensi
- Rob Pike, Concurrency is not Parallelism, The Go Blog.
- Data Race Detector, dokumentasi Go.
- asyncio dan threading, dokumentasi Python.
- Promise.all(), MDN Web Docs.
- Race condition dan Deadlock, Wikipedia.