Каналы в Go: channels, select, deadlock и конкурентное взаимодействие

Что такое channels в Go

go worker()

Как goroutine общаются через каналы

ch := make(chan string)

ch <- "hello"

msg := <-ch

package main
import "fmt"
func main() {
ch := make(chan string)
go func() {
ch <- "hello from goroutine"
}()
msg := <-ch
fmt.Println(msg)
}

Почему канал блокирует выполнение

package main
func main() {
ch := make(chan int)
ch <- 1
}

fatal error: all goroutines are asleep - deadlock!

Fatal error: all goroutines are asleep - deadlock

fatal error: all goroutines are asleep - deadlock!

package main
func main() {
ch := make(chan string)
ch <- "hello"
}

ch <- value

package main
import "fmt"
func main() {
ch := make(chan string)
go func() {
ch <- "hello"
}()
msg := <-ch
fmt.Println(msg)
}

Buffered channel и unbuffered channel

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

ch := make(chan int)

Буферизированный канал

ch := make(chan int, 3)

ch <- 1
ch <- 2
ch <- 3

ch <- 4 // блокировка, если никто не читает

Когда использовать buffered channel

Закрытие канала в Golang

close(ch)

ch := make(chan int)
go func() {
for i := 0; i < 3; i++ {
ch <- i
}
close(ch)
}()
for v := range ch {
fmt.Println(v)
}

Кто должен закрывать channel

panic: send on closed channel

panic: close of closed channel

Что будет при чтении из закрытого канала

ch := make(chan int, 1)
ch <- 10
close(ch)
v1 := <-ch // 10
v2 := <-ch // 0

v, ok := <-ch
if !ok {
fmt.Println("channel closed")
}

Select в Golang

select {
case msg := <-ch1:
fmt.Println("from ch1:", msg)
case msg := <-ch2:
fmt.Println("from ch2:", msg)
}

select {
case result := <-resultCh:
fmt.Println(result)
case <-time.After(time.Second):
fmt.Println("timeout")
}

Pipeline в Go

input → process → output

func gen(nums ...int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for _, n := range nums {
out <- n
}
}()
return out
}

Worker Pool в Golang

for _, task := range tasks {
go process(task)
}

func worker(id int, jobs <-chan int, results chan<- int) {
for job := range jobs {
results <- job * 2
}
}

Fan-out и Fan-in

Context и отмена операций через channels

func worker(ctx context.Context, jobs <-chan int) {
for {
select {
case <-ctx.Done():
fmt.Println("worker stopped")
return
case job := <-jobs:
fmt.Println("process", job)
}
}
}

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

context.WithTimeout()
context.WithDeadline()

channel + select + context

Утечка goroutine при работе с каналами Golang

func leak() {
ch := make(chan int)
go func() {
value := <-ch
fmt.Println(value)
}()
}

input → process → output

Главные правила поведения каналов

Запись в nil channel блокируется навсегда

var ch chan int
ch <- 1

Чтение из nil channel блокируется навсегда

var ch chan int
<-ch

Интересный факт: nil channels специально используют внутри select

Запись в закрытый channel вызывает panic

close(ch)
ch <- 1

panic: send on closed channel

Чтение из закрытого channel безопасно

v, ok := <-ch

Типичные ошибки при работе с channels

ch <- value
value := <-ch

Использовать time.Sleep вместо нормальной синхронизации

go worker()
time.Sleep(time.Second)

Читать через range, но не закрыть channel

for v := range ch {
fmt.Println(v)
}

Закрывать channel со стороны receiver

panic: send on closed channel

Писать в закрытый channel

close(ch)
ch <- 1

Делать бесконечные goroutine без cancellation

go func() {
for {
value := <-ch
fmt.Println(value)
}
}()

Игнорировать buffered/unbuffered поведение

Забывать кто читает из channel

1. кто пишет?
2. кто читает?
3. кто всё это остановит?

Что спрашивают на собеседованиях по channels

Шпаргалка по каналам Golang

FAQ по каналам