Bagaimana cara kerja channels?

Question

Accepted Answer

**Channel** adalah saluran yang diketik untuk **komunikasi antara goroutine** — satu goroutine mengirim nilai, yang lain menerimanya. Channel adalah cara Go goroutine melewatkan data dengan aman dan melakukan sinkronisasi, mewujudkan semangat "berbagi memori dengan berkomunikasi."

## Membuat dan menggunakan channels

```go
ch := make(chan int)     // an unbuffered channel of ints

go func() {
    ch <- 42             // SEND a value into the channel (arrow points INTO ch)
}()

value := <-ch            // RECEIVE a value from the channel (arrow points OUT)
fmt.Println(value)       // 42
```

Operator `<-` baik mengirim (`ch <- v`) maupun menerima (`v := <-ch`).

## Channels unbuffered vs buffered

```go
// UNBUFFERED — send blocks until a receiver is ready (synchronization point)
ch := make(chan int)
// sending blocks until another goroutine receives → they "rendezvous"

// BUFFERED — holds up to N values; send blocks only when the buffer is FULL
buf := make(chan int, 3)
buf <- 1; buf <- 2; buf <- 3   // these don't block (buffer has room)
buf <- 4                        // blocks now — buffer is full
```

Channel **unbuffered** disinkronkan: pengiriman menunggu penerimaan (dan sebaliknya), menjadikannya alat koordinasi. Channel **buffered** memisahkan pengirim dan penerima hingga ukuran buffer.

## Menutup channels dan ranging

```go
ch := make(chan int)
go func() {
    for i := 0; i < 3; i++ { ch <- i }
    close(ch)               // signal "no more values" (only the SENDER closes)
}()

for v := range ch {         // receives until the channel is CLOSED
    fmt.Println(v)
}

// the comma-ok form detects a closed channel
v, ok := <-ch               // ok = false if the channel is closed and drained
```

Menutup channel menandakan selesai; `range` di atas channel menerima sampai ditutup. **Hanya pengirim yang seharusnya** menutup channel.

## Jebakan deadlock dan panic umum

```go
// ❌ deadlock — sending on an unbuffered channel with no receiver
ch := make(chan int)
ch <- 1                     // 💥 fatal error: all goroutines asleep - deadlock!

// ❌ panic — operations on/after close
close(ch); close(ch)        // 💥 panic: close of closed channel
close(ch); ch <- 1          // 💥 panic: send on closed channel
v := <-closedCh             // ✅ OK — receiving from a closed channel returns the zero value
```

Deadlock (semua tersumbat) dan panic terkait penutupan adalah jebakan channel umum untuk dipahami.

## Channels arah (untuk API yang jelas)

```go
func producer(out chan<- int) { out <- 1 }   // send-only
func consumer(in <-chan int)  { <-in }         // receive-only
```

## Mengapa ini penting

Channel adalah jantung dari model konkurensi Go dan cara idiomatik bagi goroutine untuk berkomunikasi dan melakukan sinkronisasi — menerapkan filosofi inti "jangan berkomunikasi dengan berbagi memori; bagikan memori dengan berkomunikasi." Mereka memungkinkan Anda melewatkan data dengan aman di antara goroutine yang berjalan bersamaan tanpa kunci eksplisit, membangun pipeline, mendistribusikan pekerjaan, dan menandakan penyelesaian.

Memahami operasi kirim/terima, perbedaan kritis **unbuffered (sinkronisasi) vs buffered (pemisahan)**, semantik penutupan (pengirim menutup; range/comma-ok mendeteksinya), dan jebakan umum (**deadlock** dari pengiriman/penerimaan yang tersumbat, **panic** dari penutupan dua kali atau pengiriman di channel yang ditutup) sangat penting untuk menulis Go bersamaan yang benar.

Channel (dengan goroutine) adalah inti identitas Go dan termasuk di antara konsep paling penting dan paling sering diuji dalam bahasa.