📬 Каналы и select
Канал — это очередь с замком, через которую горутины передают друг другу значения и заодно договариваются о порядке действий. На каналах в Go строят пулы воркеров, пайплайны, таймауты и сигналы остановки, поэтому их поведение спрашивают почти на каждом собеседовании: чем буферизованный канал отличается от небуферизованного, что будет при записи в закрытый канал, зачем нужен nil-канал в select. Сильный ответ опирается на устройство канала в рантайме, тогда любую каверзную ситуацию можно вывести самому, а не вспоминать
🧠 Как это устроено
Что лежит внутри канала
make(chan T, n) создаёт в куче структуру hchan из runtime/chan.go и возвращает указатель на неё. Поэтому канал можно передавать в функции по значению: все копии смотрят на одну и ту же структуру. Главные поля:
buf,dataqsiz,qcount— кольцевой буфер наnэлементов, его размер и сколько в нём лежит сейчас. У небуферизованного канала буфера нетsendx,recvx— позиции записи и чтения в кольцевом буфереrecvq,sendq— очереди горутин, которые ждут чтения и записиclosed— флаг закрытияlock— мьютекс рантайма. Он защищает все поля, поэтому операции с каналом безопасны из любого числа горутин
Запись ch <- v идёт по трём веткам, в таком порядке:
- В
recvqкто-то ждёт. Значение копируется прямо в переменную ждущей горутины, мимо буфера, и горутина возвращается в очередь планировщика - Ждущих нет, а в буфере есть место. Значение копируется в
buf[sendx], запись завершается - Места нет. Горутина встаёт в
sendqи паркуется, пока её не разбудит читатель
Чтение зеркальное. Если в sendq ждёт писатель, а буфер полон, читатель забирает самый старый элемент из головы буфера, а значение писателя кладётся в хвост. Так порядок FIFO не ломается даже при прямой передаче
Отсюда разница между видами каналов. Небуферизованный канал — точка встречи: запись завершается, только когда кто-то принял значение. Буферизованный развязывает горутины во времени: писатель уходит дальше, пока в буфере есть место, и блокируется, когда буфер полон
Канал как синхронизация
Канал передаёт не только значение, но и гарантию видимости памяти. Модель памяти Go (go.dev/ref/mem) формулирует три правила:
| Событие | Что гарантировано |
|---|---|
| Запись в канал | Происходит раньше, чем завершится соответствующее чтение. Всё, что писатель сделал до отправки, читатель увидит |
| Закрытие канала | Происходит раньше чтения, которое вернуло нулевое значение из-за закрытия |
| Чтение из небуферизованного канала | Происходит раньше, чем завершится соответствующая запись. Писатель после отправки видит всё, что читатель сделал до чтения |
Последнее правило для буферизованного канала не работает, и на этом ловят на собеседовании. Для буфера ёмкости C есть обобщение: k-е чтение происходит раньше, чем завершится (k+C)-я запись. На нём держится семафор на канале: буфер ёмкости 3 пропускает не больше трёх горутин в критическую секцию
Таблица поведения
Девять клеток, которые стоит знать наизусть:
| Операция | nil-канал | Открытый канал | Закрытый канал |
|---|---|---|---|
Запись ch <- v | Блокируется навсегда | Пишет или ждёт места | Паника send on closed channel |
Чтение <-ch | Блокируется навсегда | Читает или ждёт значения | Отдаёт остаток буфера, потом сразу нулевое значение и ok == false |
close(ch) | Паника close of nil channel | Закрывает, будит всех ждущих | Паника close of closed channel |
При закрытии рантайм будит сразу всех: читатели получают нулевые значения, а писатели, которые ждали в sendq, падают с паникой. Поэтому close работает как широковещательный сигнал, а обычная запись будит только одного читателя
Проверка всех клеток, кроме вечной блокировки:
ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println("len:", len(ch), "cap:", cap(ch)) // len: 2 cap: 2
close(ch)
for i := 0; i < 3; i++ {
v, ok := <-ch
fmt.Println(v, ok) // 1 true, 2 true, 0 false
}
try("send", func() { ch <- 3 }) // send: panic: send on closed channel
try("close", func() { close(ch) }) // close: panic: close of closed channel
var nilCh chan int
try("close nil", func() { close(nilCh) }) // close nil: panic: close of nil channeltry здесь вызывает функцию и ловит панику через recover. Значения из буфера закрытого канала дочитываются до конца, и только потом приходит 0 false
Если все горутины программы встали на каналах и разбудить их некому, рантайм это замечает и роняет процесс с fatal error: all goroutines are asleep - deadlock!. Хватает одной строки ch <- 1 в main без читателя. Детектор срабатывает, только когда спят все горутины. В сервисе всегда жив кто-то ещё, хотя бы HTTP-сервер, поэтому зависшую горутину детектор не заметит, и она будет висеть молча
Направление канала
Тип chan<- T разрешает только запись, <-chan T только чтение. Двунаправленный канал неявно приводится к любому из них при присваивании или передаче в функцию. Функция, которая возвращает <-chan T, говорит вызывающему коду: читай, а закрою я сам. Компилятор не даст закрыть канал только для чтения, ошибка ловится при сборке, а не на проде
select
select ждёт сразу несколько операций с каналами и выполняет одну. Спецификация описывает шаги так:
- При входе один раз и по порядку вычисляются все каналы и все отправляемые значения
- Если готовы несколько операций, одна выбирается равновероятно случайно
- Если не готова ни одна и есть
default, выполняетсяdefault - Иначе
selectблокируется, пока что-то не станет готово
Случайность проверяется просто: два канала, в обоих лежит по значению, 10 000 повторов. Вышло a: 4982 b: 5018. Порядок case в коде приоритета не задаёт, и полагаться на него нельзя
В рантайме select перемешивает порядок опроса, блокирует все каналы по возрастанию адреса, чтобы два select на одних и тех же каналах не заперли друг друга, и проходит три шага: ищет готовую операцию, встаёт в очереди всех каналов разом, а после пробуждения снимает себя из очередей остальных
select {} без веток блокирует горутину навсегда. select только с nil-каналами без default тоже
🛠️ На практике
Таймаут и неблокирующая операция
Ожидание с таймаутом пишут через второй канал. В сервисе это почти всегда ctx.Done(), о нём страница про context:
select {
case v := <-res:
return v, nil
case <-ctx.Done():
return 0, ctx.Err()
}default превращает операцию в неблокирующую. Так делают «отправь метрику, если очередь свободна, иначе выброси», чтобы медленный потребитель не тормозил горячий путь:
select {
case events <- e:
default:
dropped.Add(1) // буфер полон, событие теряем сознательно
}nil-канал выключает ветку select
Чтение из nil-канала никогда не готово, и этим пользуются: присвоить каналу nil значит убрать его ветку из select. Слияние двух каналов до закрытия обоих:
Go · Сумма значений из двух каналов
func gen(vals ...int) <-chan int {
out := make(chan int)
go func() {
defer close(out) // закрывает тот, кто пишет
for _, v := range vals {
out <- v
}
}()
return out
}
func main() {
a, b := gen(1, 2, 3), gen(10, 20)
sum := 0
for a != nil || b != nil {
select {
case v, ok := <-a:
if !ok {
a = nil // закрытый канал выключаем из select
continue
}
sum += v
case v, ok := <-b:
if !ok {
b = nil
continue
}
sum += v
}
}
fmt.Println("sum:", sum) // sum: 36
}Без a = nil закрытый канал оставался бы всегда готовым, и цикл крутился бы на нулевых значениях, съедая ядро
Таймеры в последних версиях
С Go 1.23 каналы time.Timer и time.Ticker небуферизованные, а таймер, на который больше нет ссылок, собирает GC, даже если Stop не вызвали. Новое поведение включается строкой go 1.23 или выше в go.mod: тот же код на компиляторе 1.23 печатает cap(t.C) равным 0, а со строкой go 1.22 равным 1. С Go 1.27 настройку asynctimerchan, которая возвращала старый вариант, удалили. Практический вывод: time.After в цикле select больше не копит таймеры до их срабатывания, а код, который проверял len(t.C), надо переписать на неблокирующее чтение
⚠️ Где ошибаются
Закрывать канал со стороны читателя или из нескольких писателей. Второй close или запись после закрытия роняют процесс паникой, recover тут не выход. Если писателей много, их ждут через sync.WaitGroup, и закрывает канал одна горутина после Wait
Терять горутину на небуферизованном канале результата. Типичный код: горутина считает результат и пишет в res, а вызывающий ждёт его в select с таймаутом. Таймаут сработал, читать res больше некому, и горутина висит на записи до конца жизни процесса. 100 вызовов с таймаутом в замере оставили 100 зависших горутин. Канал make(chan int, 1) чинит это: запись проходит в буфер, горутина завершается, канал собирает GC
Ждать гарантий видимости от буферизованного канала. «Писатель отправил, значит читатель уже всё сделал» верно только для небуферизованного канала. С буфером писатель уходит дальше сразу. Если писателю нужно дождаться обработки, нужен ответный канал или WaitGroup
Проверять канал через len перед чтением. Между len(ch) > 0 и <-ch другая горутина успеет забрать значение. Узнать, можно ли читать без блокировки, позволяет только select с default
Делать канал там, где хватит мьютекса. Счётчик или кэш под каналом-замком медленнее и запутаннее, чем sync.Mutex. Каналы удобны, когда передаётся владение данными или сигнал, а для защиты общего состояния есть примитивы sync, о них следующая страница
🎯 Вопросы с собеседований
Чем буферизованный канал отличается от небуферизованного?
Небуферизованный канал не хранит значений: запись завершается, только когда читатель принял значение, это точка синхронизации двух горутин. Буферизованный хранит до cap значений в кольцевом буфере, писатель блокируется только на полном буфере, а читатель только на пустом. Из-за этого у небуферизованного канала сильнее гарантия памяти: писатель после отправки видит всё, что сделал читатель до чтения
Как канал устроен внутри?
Это структура hchan в куче: кольцевой буфер с индексами записи и чтения, две очереди ждущих горутин, флаг закрытия и мьютекс, который защищает всё это. make возвращает указатель, поэтому копии канала смотрят на одну структуру. Если при записи кто-то уже ждёт чтения, значение копируется прямо ему, мимо буфера
Что будет при чтении из закрытого канала? А при записи?
Чтение сначала отдаёт всё, что осталось в буфере, а потом сразу возвращает нулевое значение без блокировки. Отличить его от настоящего нуля помогает форма v, ok := <-ch, где ok будет false. Запись в закрытый канал паникует с send on closed channel. Повторный close тоже паника
Что происходит с nil-каналом?
Запись и чтение блокируются навсегда, close паникует. В select ветка с nil-каналом никогда не готова, и это полезно: присвоив каналу nil, можно выключить ветку, например когда источник уже закрыт. Объявленный через var ch chan int канал равен nil, пока его не создали через make
Как select выбирает ветку, если готовы несколько?
Случайно и равновероятно, так сказано в спецификации. Порядок case в коде приоритета не даёт. Если готовых нет, выполняется default, а без него select ждёт. Приоритет, если он нужен, делают вложенным select или отдельной проверкой перед основным
Кто должен закрывать канал и зачем его вообще закрывать?
Закрывает писатель, когда точно больше не будет писать, потому что запись в закрытый канал паникует. Закрывать нужно, только если читатель ждёт сигнала конца, например в for range ch. Канал, который просто перестали использовать, закрывать необязательно, его соберёт GC. При нескольких писателях закрывает отдельная горутина после WaitGroup.Wait
Как сделать таймаут на операцию с каналом?
select с двумя ветками: сама операция и <-ctx.Done() или <-time.After(d). В сервисе предпочитают контекст, потому что он протаскивает отмену вниз по вызовам. С Go 1.23 time.After в цикле не держит таймеры до срабатывания, их собирает GC
Почему горутина может утечь на канале?
Она заблокирована на записи или чтении, а другой стороны больше нет: вызывающий ушёл по таймауту, читатель вышел из цикла раньше. Детектор дедлоков такое не ловит, пока в процессе есть живые горутины. Лечится буфером на один элемент для канала результата или отменой через контекст. В Go 1.27 найти такие горутины помогает профиль goroutineleak
Что выведет программа, где в main пишут в небуферизованный канал без читателя?
Она упадёт с fatal error: all goroutines are asleep - deadlock!. Запись ждёт читателя, других горутин нет, и рантайм видит, что разбудить main некому. Если рядом крутится хоть одна горутина, например цикл с time.Sleep, процесс не упадёт, а просто зависнет
Когда канал, а когда мьютекс?
Канал, когда данные или задача переходят от одной горутины к другой, или нужен сигнал: готово, стоп, таймаут. Мьютекс, когда несколько горутин читают и меняют одно общее состояние, например счётчик или кэш. Мьютекс здесь быстрее и проще читается
📚 Что почитать
- Спецификация Go: Channel types и Select statements — точные правила, на которые ссылается таблица поведения
- The Go Memory Model: Channel communication — гарантии видимости памяти и семафор на буферизованном канале
- Go Concurrency Patterns: Pipelines and cancellation — статья в блоге Go про пайплайны, закрытие каналов и отмену
- runtime/chan.go — исходник канала, комментарии к
chansendиchanrecvобъясняют ветки записи и чтения