Чем буферизированный канал отличается от небуферизированного и что будет при чтении из закрытого или nil-канала?
Проверила команда Сопровод · Обновлено
Короткий ответ
Отправка в небуферизированный канал ждет, пока другая горутина заберет значение: это передача из рук в руки. Буферизированный make(chan T, n) принимает до n значений без читателя и блокирует отправителя, когда буфер полон. Закрытый канал отдает остаток буфера, потом сразу нулевое значение и ok == false. Чтение из nil-канала блокируется навсегда.
Почему этот вопрос задают
Каналы — основной способ передавать данные между горутинами. По ответу видно, понимает ли кандидат еще до запуска кода, где программа заблокируется, а где упадет с паникой.
Как рассуждать
- Сравните отправку: без буфера она ждет читателя, с буфером ждет, только когда буфер полон
- Покажите
lenиcap: сколько значений лежит в буфере и сколько он вмещает - Разберите закрытый канал: остаток читается, потом нулевое значение и
ok == false, отправка дает панику - Закончите
nil-каналом: чтение и отправка в нем блокируются навсегда
Ответ с примером
Сервер онлайн-игры собирает игроков на матч в канал queue с буфером на двоих. Ира и Макс встали в очередь без читателя, и main пошел дальше: len показывает 2 значения в буфере, cap — емкость 2. Третья отправка заблокировала бы main до освобождения места, а читателя здесь нет, и программа упала бы с ошибкой all goroutines are asleep - deadlock!. С make(chan string) вместо make(chan string, 2) это случится уже на первой отправке: без буфера отправка сразу ждет читателя.
После close цикл range выбрал обоих игроков и завершился сам. Следующее чтение вернуло пустую строку и false: канал закрыт и пуст. Отправка в закрытый канал вызвала бы панику, а чтение из nil-канала заблокировало бы main навсегда и уронило бы программу с той же ошибкой.
func main() {
queue := make(chan string, 2)
queue <- "Ира"
queue <- "Макс"
fmt.Println(len(queue), cap(queue))
close(queue)
for p := range queue {
fmt.Println("в матч:", p)
}
p, ok := <-queue
fmt.Printf("%q %v\n", p, ok)
}2 2 в матч: Ира в матч: Макс "" false
Как ответить сильнее
Что добавит опытный кандидат
Что спросят следом
Доступно по подписке
Приемы опытных и готовые ответы
Частые ошибки
«Буферизированный канал никогда не блокирует отправителя»
Уточните, что отправка блокируется, когда буфер полон. Буфер сглаживает всплески, но медленного читателя не заменяет
«Чтение из закрытого канала вызывает панику»
Поправьте: паника бывает при отправке в закрытый канал и при повторном
close. Чтение отдает остаток буфера, потом нулевое значение иok == false«Объявил
var ch chan int— и канал готов к работе»Объясните, что такой канал равен
nil: отправка и чтение заблокируются навсегда, аcloseвызовет панику. Создавайте канал черезmake«Чтобы горутины не ждали друг друга, поставлю буфер на 10 000»
Скажите, что большой буфер прячет проблему: память растет, а отставание читателя видно слишком поздно. Размер буфера выбирайте под ожидаемый всплеск
Сигналы для интервьюера
Сильный ответ
Для каждого вида канала говорит, где горутина заблокируется, где получит нулевое значение и где упадет, и проверяет это на коротком примере
Тревожный сигнал
Создает канал с буфером через make(chan T, n), но не может объяснить, зачем вообще нужен канал без буфера
Красный флаг
Ждет, что программа из одной горутины спокойно отправит значение в канал без буфера, и не видит в ней взаимной блокировки
Как еще могут спросить
- Чем отличается
make(chan int)отmake(chan int, 10)? - Что произойдет при чтении из закрытого канала в Go?
- Что будет, если писать в
nil-канал? - Когда в Go нужен буферизированный канал?











