Piye cara channel bisa gumana?

Question

Accepted Answer

**Channel** iku saluran sing diketik kanggo **komunikasi antarane goroutine** — siji goroutine ngirim nilai, goroutine liyane nampa. Channel iku cara Goroutine Go ngirim data kanthi aman lan nyikronisasi, nggambarake semboyo "share memory by communicating".

## Nggawe lan nggunakake channel

```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 `<-` ngirim (`ch <- v`) lan nampa (`v := <-ch`).

## Channel ora kebuffer vs kebuffer

```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 **ora kebuffer** sinkron: ngirim nunggu nampa (lan sabalione), dadine alat koordinasi. Channel **kebuffer** mupisake pengirim lan penerima nganti ukuran buffer.

## Nutup channel lan iterasi

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

Nutup channel nuduhake rampung; `range` luwih channel nampa nganti ditutup. **Mung pengirim sing kudu nutup** channel.

## Deadlock umum lan panic pitfalls

```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 (kabeh blokir) lan panic sing gegandhengan tutup iku bug channel umum sing kudu dimengerti.

## Channel directional (kanggo API sing jelas)

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

## Kenapa iku penting

Channel iku jantung model concurrency Go lan cara idiomatik kanggo goroutine komunikasi lan sinkron — nggambarakake filosofi inti "aja komunikasi kanthi bagi memori; bagi memori kanthi komunikasi". Bisa ngirim data kanthi aman antarane goroutine concurrent tanpa trance eksplisit, mbangun pipeline, distribusi kerja, lan nuduhake rampung.

Mengerti operasi ngirim/nampa, bedane penting antarane channel **ora kebuffer (sinkronisasi) vs kebuffer (mupisake)**, semantik nutup (pengirim nutup; range/comma-ok ditekne), lan pitfalls umum (**deadlock** saking ngirim/nampa blokir, **panic** saking nutup loro kali utawa ngirim ing channel sing ditutup) iku penting kanggo nulis Go concurrent sing bener.

Channel (nganggo goroutine) iku pusat identitas Go lan luwih penting lan konsep sing asring diuji ing basa.