Как завершить много горутин

Завершение множества горутин в Go требует организованного подхода, так как горутины не предоставляют прямых средств для их остановки. Основные практики включают использование каналов для сигнализации о необходимости завершения, контекстов для управления временем выполнения и ограничениями, а также синхронизации с помощью sync.WaitGroup. Эти методы позволяют элегантно и безопасно управлять жизненным циклом параллельных процессов, минимизируя риски утечек памяти и «зомби»-горутин.

Использование каналов для управления горутинами

Каналы — один из наиболее часто используемых подходов для остановки горутин. Идея заключается в том, чтобы создать канал, закрытие которого служит сигналом для всех горутин завершить работу. Каждая горутина в цикле проверяет этот канал через select и выходит, если он закрыт.

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(stopCh <-chan struct{}, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    for {
        select {
        case <-stopCh:
            fmt.Printf("Worker %d stopping\n", id)
            return
        default:
            // выполнение полезной работы
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    stopCh := make(chan struct{})

    // запуск горутин
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(stopCh, &wg, i)
    }

// остановка горутин после 3 секунд
time.Sleep(3 * time.Second)
close(stopCh) // отправка сигнала всем горутинам остановиться
wg.Wait()     // ожидание завершения всех горутин

}

Закрытие канала `stopCh` рассылает сигнал всем горутинам, которые слушают этот канал. Это безопасно, так как закрытие канала — единственная операция, которую можно выполнить без гонок данных. После закрытия канала все горутины, ожидающие в `select`, получат нулевое значение и завершатся.

## Использование пакета `context`

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

```go
package main

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

func worker(ctx context.Context, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d stopping\n", id)
            return
        default:
            // выполнение полезной работы
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)

    // запуск горутин
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(ctx, &wg, i)
    }

    wg.Wait() // ожидание завершения всех горутин
    cancel()  // убедиться, что все ресурсы освобождены
}

Здесь context.WithTimeout создаёт контекст, который автоматически отменяется через 3 секунды. Горутины слушают ctx.Done() и завершаются при отмене. Вызов cancel() в конце гарантирует освобождение ресурсов, даже если горутины уже завершились.

Подводные камни и лучшие практики

• Всегда используйте sync.WaitGroup для ожидания завершения всех горутин. Это предотвращает преждевременный выход из main и утечку горутин.
• Не закрывайте канал из нескольких горутин — это вызовет панику. Закрытие должно происходить только в одном месте, обычно в главной горутине.
• Проверяйте ctx.Err() после ctx.Done(), чтобы понять причину отмены: context.Canceled или context.DeadlineExceeded.
• Избегайте time.Sleep в реальном коде для синхронизации; используйте таймеры или контексты с дедлайнами.
• При использовании каналов убедитесь, что все горутины слушают один и тот же канал, иначе они не получат сигнал.

Когда использовать какой метод

• Каналы — простой и эффективный способ для случаев, когда нужно явно управлять остановкой извне, например, по нажатию кнопки или получению команды.
• Контекст — предпочтителен, когда есть иерархия горутин, таймауты, дедлайны или необходимость передавать дополнительные значения (например, ID запроса). Контекст также стандартизирован в стандартной библиотеке и широко используется в HTTP-серверах и клиентах.

Коротко

• Для остановки множества горутин используйте закрытие канала или отмену контекста.
• Всегда синхронизируйте завершение через sync.WaitGroup.
• Каналы подходят для простых сценариев, контекст — для сложных с таймаутами и иерархией.
• Не закрывайте канал из нескольких горутин; проверяйте ctx.Err() для диагностики.