Как работают каналы?

Question

Accepted Answer

**Канал** — это типизированный проводник для **обмена данными между goroutines** — одна горутина отправляет значения, другая их получает. Каналы — это способ, которым goroutines Go безопасно передают данные и синхронизируются, воплощая девиз "share memory by communicating".

## Создание и использование каналов

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

Оператор `<-` как отправляет (`ch <- v`), так и получает (`v := <-ch`).

## Небуферизованные и буферизованные каналы

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

**Небуферизованные** каналы синхронизируют: отправка ждёт получения (и наоборот), делая их инструментом координации. **Буферизованные** каналы разделяют отправителя и получателя до размера буфера.

## Закрытие каналов и итерация

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

Закрытие канала сигнализирует о завершении; `range` по каналу получает значения, пока он не закрыт. **Только отправитель должен закрывать** канал.

## Распространённые deadlock-и и паники

```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-и (все заблокированы) и паники, связанные с закрытием, — частые ошибки работы с каналами.

## Направленные каналы (для ясного API)

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

## Почему это важно

Каналы — это сердце модели конкурентности Go и идиоматичный способ обмена данными и синхронизации goroutines — реализация основной философии "don't communicate by sharing memory; share memory by communicating". Они позволяют безопасно передавать данные между конкурентными горутинами без явных блокировок, строить конвейеры, распределять работу и сигнализировать о завершении.

Понимание операций отправки/получения, критического различия **небуферизованные (синхронизирующие) vs буферизованные (разделяющие)**, семантики закрытия (отправитель закрывает; range/comma-ok это обнаруживают) и распространённых ошибок (**deadlock-и** от заблокированных отправок/получений, **паники** от двойного закрытия или отправки в закрытый канал) необходимо для написания корректного конкурентного Go.

Каналы (с горутинами) — центральное место в идентичности Go и среди наиболее важных и часто проверяемых концепций в языке.