Bagaimana saluran berfungsi?

Question

Accepted Answer

**Saluran** adalah saluran bertipe untuk **komunikasi antara goroutin** — satu goroutin mengirim nilai, goroutin lain menerima. Saluran adalah cara goroutin Go melewatkan data dengan aman dan tersinkronisasi, mewujudkan motto "share memory by communicating".

## Membuat dan menggunakan saluran

```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 `<-` mengirim (`ch <- v`) dan menerima (`v := <-ch`).

## Saluran tanpa buffer vs dengan buffer

```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
```

Saluran **tanpa buffer** menyinkronkan: pengiriman menunggu penerimaan (dan sebaliknya), menjadikan mereka alat koordinasi. Saluran **dengan buffer** memisahkan pengirim dan penerima hingga ukuran buffer.

## Menutup saluran dan penjelajahan rentang

```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 saluran menandakan penyelesaian; `range` pada saluran menerima hingga ditutup. **Hanya pengirim yang harus menutup** saluran.

## 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 terblokir) dan panic terkait penutupan adalah bug saluran umum yang perlu dipahami.

## Saluran arah (untuk API yang jelas)

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

## Mengapa hal ini penting

Saluran adalah jantung model kesamaan Go dan cara idiomatis untuk goroutin berkomunikasi dan tersinkronisasi — menerapkan filosofi inti "jangan berkomunikasi dengan berbagi memori; bagikan memori melalui komunikasi". Mereka memungkinkan Anda melewatkan data dengan aman antara goroutin bersamaan tanpa kunci eksplisit, membangun pipa, mendistribusikan pekerjaan, dan menandakan penyelesaian.

Memahami operasi pengiriman/penerimaan, perbedaan penting **saluran tanpa buffer (menyinkronkan) vs dengan buffer (memisahkan)**, semantik penutupan (pengirim menutup; range/comma-ok mendeteksinya), dan jebakan umum (**deadlock** dari pengiriman/penerimaan yang terblokir, **panic** dari penutupan dua kali atau pengiriman di saluran tertutup) sangat penting untuk menulis Go bersamaan yang benar.

Saluran (bersama goroutin) adalah inti identitas Go dan merupakan salah satu konsep yang paling penting dan paling sering diuji dalam bahasa.