Краткий ответ

При передаче канала в функцию копируется значение канала, но не создаётся новый канал. Копия и исходная переменная обращаются к одному внутреннему объекту канала, поэтому отправка через одну из них доступна для получения через другую.

Исторический контекст

Каналы в Go предназначены не только для передачи данных, но и для синхронизации горутин. Такой подход уменьшает необходимость вручную защищать общую память и основан на идее обмена сообщениями между независимыми участниками.

Чтобы передавать канал в функции и горутины без копирования очереди данных, канал представлен небольшим значением-ссылкой на общий внутренний объект. Это позволяет разделять канал между несколькими участниками явно и предсказуемо.

Постановка проблемы

Если ошибочно считать передачу канала созданием независимой очереди, можно ожидать значения, которые никогда не будут получены, или неверно оценить порядок синхронизации. На практике несколько переменных типа канала могут быть копиями одного канала, а значит, их операции конкурируют за одну очередь и один набор состояний.

Особенно важно это при закрытии: закрытие через любую копию закрывает общий канал. После этого отправка через исходную переменную или её копию приводит к панике, а получение видит закрытое состояние и оставшиеся буферизованные значения.

Подробное решение

Копируется дескриптор канала — значение, которое указывает на общий runtime-объект. Не копируются отдельно буфер, очередь сообщений, состояние закрытия или набор ожидающих горутин.

package main

import "fmt"

func send(ch chan int) {
    ch <- 42
}

func main() {
    ch := make(chan int, 1)
    send(ch)
    fmt.Println(<-ch)
}

Функция получает копию значения ch, но отправляет в тот же буферизованный канал. Поэтому main получает число 42 через исходную переменную.

Копирование канала отличается от копирования данных, передаваемых через него. Если в канал отправлена структура, правила копирования этой структуры зависят от её типа, но сам канал при передаче функции не превращается в отдельную очередь.

Канал можно передавать нескольким горутинам. Отправители используют общую очередь, получатели конкурируют за доступные значения, а операции канала обеспечивают необходимую синхронизацию между ними. Порядок получения определяется готовностью операций и планированием, если несколько горутин одновременно ожидают.

Направление канала в типе ограничивает доступ на уровне компиляции: копия канала, переданная как только для отправки или только для получения, всё равно ссылается на тот же канал. Это ограничение интерфейса, а не создание нового runtime-объекта.

Канал nil также копируется как значение nil; все его копии сохраняют поведение операций над nil-каналом. Закрывать канал следует только через переменную, которая имеет право закрытия, обычно владелец канала — отправляющая сторона после завершения всех отправок.

Ситуация из практики

Сервис передаёт один канал результатов нескольким функциям-воркерам. Один разработчик решил передавать канал по значению и предположил, что каждый воркер получит собственную очередь, поэтому ожидал отдельную обработку каждого результата.

Вариант с отдельным каналом для каждого воркера действительно изолировал бы очереди, но потребовал бы дополнительной маршрутизации, закрытия нескольких каналов и объединения результатов. Вариант с общей переменной канала ничего не меняет: даже если переменная передаётся по значению, все копии используют одну очередь.

Выбранное решение — явно использовать один общий канал, если нужен пул конкурирующих воркеров. Каждый результат обрабатывается одним из получателей, а канал закрывается после завершения всех отправителей. Это сохраняет простой протокол владения и не создаёт лишних очередей.

Что кандидаты часто упускают

Можно ли закрыть канал через копию, полученную функцией?

Да, если статический тип копии допускает закрытие. Закрытие действует на общий канал, поэтому после возврата функции исходная переменная также обозначает закрытый канал. Если копия имеет тип только для получения, операция закрытия не скомпилируется, хотя сам runtime-объект тот же.

Меняется ли поведение канала, если передать его в несколько функций по значению?

Нет, сам канал не дублируется. Все функции работают с одной очередью, общим буфером и общим состоянием закрытия. Если несколько функций получают из него, каждое значение обычно забирает только один успешно завершивший операцию получатель, а не все получатели одновременно.

Что произойдёт, если после передачи канала функция заменит свою локальную переменную новым каналом?

Замена локальной переменной изменит только локальную ссылку и не повлияет на канал вызывающей стороны. До замены обе переменные указывали на один объект, но присваивание нового канала не переподключает исходную переменную и не меняет уже существующую очередь.