Можно ли оставлять канал открытым в Go? Последствия и правильная практика

Можно ли оставлять канал открытым? Да, но с оговорками

Короткий ответ: да, технически можно оставить канал открытым, если программа завершается. Go — язык с управляемой памятью, и когда основная горутина (main) завершается, runtime убивает все горутины и освобождает ресурсы, включая открытые каналы. Ваша программа не «утекает» в классическом смысле.

Однако это плохая практика в реальных приложениях по нескольким причинам:

• Утечка горутин: Если main не завершается (например, HTTP-сервер), а канал не закрыт, горутина-читатель будет вечно ждать данных — это утечка.
• Неопределённое поведение при записи: Если другая горутина попытается записать в канал, который никто не читает, она заблокируется навсегда.
• Затруднённая отладка: Открытые каналы маскируют логические ошибки. Закрытие канала — это явный сигнал «данные закончились».

Как правильно завершать воркеры?

В вашем примере проблема в том, что range по каналу завершается только при его закрытии. Если вы не закрываете канал, горутина worker остаётся в состоянии ожидания. Программа завершается только потому, что main завершается раньше.

Вот правильный паттерн с закрытием канала:

package main

import (
    "fmt"
    "time"
)

func worker(tasks <-chan int) {
    for task := range tasks {
        fmt.Println("Обработана задача:", task)
    }
    fmt.Println("Воркер завершился")
}

func main() {
    tasks := make(chan int, 3) // буферизированный канал — хорошая практика
    go worker(tasks)

    tasks <- 1
    tasks <- 2
    tasks <- 3
    close(tasks) // явно закрываем канал

    // Даём время воркеру завершиться
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Программа завершена")
}

Паттерн с сигнальным каналом (graceful shutdown)

В реальных приложениях вы не можете просто закрыть канал задач — воркер может быть занят. Используйте отдельный канал для остановки:

package main

import (
    "fmt"
    "time"
)

func worker(tasks <-chan int, done <-chan struct{}) {
    for {
        select {
        case task, ok := <-tasks:
            if !ok {
                fmt.Println("Канал задач закрыт")
                return
            }
            fmt.Println("Обработана задача:", task)
        case <-done:
            fmt.Println("Получен сигнал остановки")
            return
        }
    }
}

func main() {
    tasks := make(chan int)
    done := make(chan struct{})
    go worker(tasks, done)

    tasks <- 1
    tasks <- 2

    // Имитируем внешнюю остановку
    close(done)
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Программа завершена")
}

Когда можно оставить канал открытым?

• В короткоживущих утилитах (CLI-скрипты), где main завершается сразу после работы.
• В тестах — если вы явно контролируете время жизни.

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

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context, tasks <-chan int) {
    for {
        select {
        case task, ok := <-tasks:
            if !ok {
                return
            }
            fmt.Println("Обработана задача:", task)
        case <-ctx.Done():
            fmt.Println("Работа прервана:", ctx.Err())
            return
        }
    }
}

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

    tasks := make(chan int)
    go worker(ctx, tasks)

    tasks <- 1
    tasks <- 2

    // Отменяем контекст через 50 мс
    time.AfterFunc(50*time.Millisecond, cancel)

    time.Sleep(100 * time.Millisecond)
    fmt.Println("Программа завершена")
}