Что можно делать с закрытым каналом в Go?

Операции с закрытыми каналами в Go

После закрытия канала в Go (close(ch)) его состояние меняется фундаментально — он переходит в закрытый (closed) статус, что определяет возможные операции и их поведение.

1. Основное правило закрытия канала

Закрыть канал может только отправляющая сторона (sender), и только один раз. Попытка закрыть уже закрытый канал вызывает панику:

ch := make(chan int)
close(ch)
close(ch) // panic: close of closed channel

2. Что можно делать с закрытым каналом

A. Получение данных (чтение)

С закрытого канала можно бесконечно читать значения, но они будут нулевыми для типа канала:

ch := make(chan string, 2)
ch <- "hello"
ch <- "world"
close(ch)

for i := 0; i < 5; i++ {
    v, ok := <-ch
    fmt.Printf("val=%v, ok=%v\n", v, ok)
}
// Вывод:
// val=hello, ok=true
// val=world, ok=true
// val=, ok=false  // нулевое значение для string после закрытия
// val=, ok=false
// val=, ok=false

Ключевой момент: операция чтения возвращает два значения: value, ok. Когда ok == false, канал закрыт и value является нулевым значением типа (nil для указателей, 0 для чисел, "" для строк).

B. Проверка в циклах for range

Цикл for range автоматически завершается при закрытии канала:

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

for v := range ch {
    fmt.Println(v) // Вывод: 0, 1, 2
}
// После close(ch) цикл автоматически завершается

C. Использование в операторах select

Закрытый канал в select работает как always-ready channel — его ветка чтения всегда доступна:

ch := make(chan int)
close(ch)

select {
case v := <-ch:
    fmt.Println("Received:", v) // v = 0, ok = false
default:
    fmt.Println("Default") // Не выполнится - канал ready
}

D. Определение состояния канала

Можно проверять, закрыт ли канал, через двухзначную форму чтения:

func isClosed(ch <-chan int) bool {
    _, ok := <-ch
    return !ok
}

3. Что НЕЛЬЗЯ делать с закрытым каналом

A. Отправка данных (запись)

Попытка отправки в закрытый канал вызывает немедленную панику:

ch := make(chan int)
close(ch)
ch <- 42 // panic: send on closed channel

B. Повторное закрытие

Как упомянуто выше, повторный close() вызывает панику.

4. Практические применения закрытых каналов

A. Сигнализация завершения

Чаще всего каналы закрывают для сигнализации о завершении работы:

done := make(chan struct{})
go func() {
    // Выполняем работу
    time.Sleep(100 * time.Millisecond)
    close(done) // Сигнал завершения
}()

// Ожидание сигнала
select {
case <-done:
    fmt.Println("Work completed")
}

B. Распространение события множеству горутин

Закрытый канал одновременно сигнализирует всем читающим горутинам:

workers := 5
stopCh := make(chan struct{})

for i := 0; i < workers; i++ {
    go func(id int) {
        for {
            select {
            case <-stopCh:
                fmt.Printf("Worker %d stopped\n", id)
                return
            default:
                // Работа
            }
        }
    }(i)
}

time.Sleep(time.Second)
close(stopCh) // Все 5 горутин получат сигнал

C. Обработка завершения в пулах горутин

func workerPool(input <-chan int, done <-chan struct{}) {
    for {
        select {
        case n := <-input:
            process(n)
        case <-done:
            return // Все горутинки завершаются одновременно
        }
    }
}

5. Особые случаи и техники

A. Каналы с буфером

При закрытии буферизованного канала данные в буфере остаются доступными для чтения:

ch := make(chan int, 3)
ch <- 1
ch <- 2
close(ch)

fmt.Println(<-ch) // 1
fmt.Println(<-ch) // 2
fmt.Println(<-ch) // 0 (нулевое значение после буфера)

B. Паттерн "отмена через закрытие"

type Server struct {
    stop chan struct{}
}

func (s *Server) Stop() {
    close(s.stop) // Все внутренние горутины получат сигнал
}

C. Комбинация с context.Context

Часто закрытие канала используется вместе с контекстом:

func listen(ctx context.Context, ch <-chan Message) {
    for {
        select {
        case msg := <-ch:
            handle(msg)
        case <-ctx.Done():
            return // ctx.Done() часто возвращает закрытый канал
        }
    }
}

6. Лучшие практики

1. Закрывайте каналы только отправителем — горутине, которая пишет в канал
2. Не закрывайте канал для сигнализации ошибок — используйте отдельные каналы ошибок
3. Проверяйте состояние при чтении через v, ok := <-ch в критичных местах
4. Используйте defer close(ch) при закрытии каналов в функциях для избежания забытого закрытия
5. Никогда не пишите в канал после его закрытия — структурируйте код так, чтобы это было невозможно

Заключение

Закрытый канал в Go — это мощный механизм синхронизации, который позволяет:

• Эффективно сигнализировать о завершении множеству горутин одновременно
• Автоматически завершать циклы for range
• Обеспечивать безопасное чтение нулевых значений без паники
• Создавать паттерны управления жизненным циклом горутин и сервисов

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