Concurrency di Go: Goroutine, Channel, dan Select

Kenapa Goroutine?

Salah satu alasan utama developer pilih Go itu concurrency model-nya. Bukan pake thread OS yang berat, Go punya goroutine — lightweight thread yang dikelola oleh Go runtime. Biaya bikin goroutine cuma beberapa KB, jadi kamu bisa spin ribuan goroutine tanpa masalah.

Goroutine 101

Cara pake goroutine semudah nambahin keyword go di depan function call:

package main

import (
"fmt"
"time"
)

func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}

func main() {
go say("dari goroutine") // jalan di background
say("dari main") // jalan di main thread
}

Tanpa go, function say jalan sequential — outputnya berantrian. Dengan go, dua call jalan concurrent.

Channel — Komunikasi Antar Goroutine

Golang punya prinsip: "Don't communicate by sharing memory; share memory by communicating." Channel adalah pipa yang menghubungkan goroutine satu ke lainnya.

func main() {
ch := make(chan string)

go func() {
ch <- "halo dari goroutine!" // kirim data ke channel
}()

msg := <-ch // terima data dari channel
fmt.Println(msg)
}

Channel bisa buffered atau unbuffered. Unbuffered channel (default) — pengirim nunggu sampe ada penerima siap. Buffered channel — bisa kirim beberapa nilai tanpa nunggu sampai buffer penuh.

ch := make(chan int, 3) // buffer capacity 3
ch <- 1
ch <- 2
ch <- 3 // aman, belum penuhSelect — Multiplexing Channel

Select kaya switch, tapi buat channel — nunggu sampe salah satu channel siap:

func main() {
c1 := make(chan string)
c2 := make(chan string)

go func() {
time.Sleep(1 * time.Second)
c1 <- "satu"
}()
go func() {
time.Sleep(2 * time.Second)
c2 <- "dua"
}()

select {
case msg1 := <-c1:
fmt.Println("terima:", msg1)
case msg2 := <-c2:
fmt.Println("terima:", msg2)
case <-time.After(3 * time.Second):
fmt.Println("timeout!")
}
}Pattern Umum

Worker pool — pola klasik: bikin N goroutine worker yang duduk di channel, kirim task ke channel, hasilnya dikumpulin lewat channel lain. Fan-in — gabungin multiple channel jadi satu. Fan-out — distribusi data dari satu channel ke banyak goroutine.

Yang Perlu Diperhatikan

Deadlock — kalo semua goroutine nunggu, Go runtime panic

Race condition — akses variable yang sama dari multiple goroutine tanpa sync. Pake -race flag buat deteksi

Goroutine leak — goroutine yang duduk nunggu channel tapi gak ada yang kirim. Pake context cancel untuk cleanup

Jangan pake sync.Mutex kalo bisa pake channel — channel lebih idiomatis

Concurrency di Go itu elegant. Mulai dari goroutine sederhana, evolve ke channel, lalu select buat orchestration. Setelah paham ini, kamu bisa nulis API server, background worker, atau data pipeline tanpa pusing.