Что будет, если вызвать cancel несколько раз?

Повторный вызов context.CancelFunc

При работе с контекстами (context.Context) в Go, функция cancel() (точнее, CancelFunc), возвращаемая методами context.WithCancel(), context.WithTimeout() и context.WithDeadline(), может быть вызвана более одного раза. Повторные вызовы не приводят к ошибкам и имеют вполне определённое поведение.

Спецификация поведения

При первом вызове CancelFunc() происходит следующее:

• Канал Done() контекста закрывается.
• Все горутины, ожидающие на этом канале (через select или <-ctx.Done()), получают сигнал для завершения.
• Контекст переходит в состояние "canceled" (его метод Err() начинает возвращать context.Canceled).

При втором и всех последующих вызовах:

• Функция не выполняет никаких дополнительных действий и не генерирует панику.
• Это идемпотентная операция: многократный вызов даёт тот же результат, как и однократный.

Пример и демонстрация

Рассмотрим код, который иллюстрирует это поведение:

package main

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

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup

    // Горутина, ожидающая завершения контекста
    wg.Add(1)
    go func() {
        defer wg.Done()
        <-ctx.Done()
        fmt.Println("Горутина получила сигнал от ctx.Done()")
        fmt.Printf("Ошибка контекста: %v\n", ctx.Err())
    }()

    // Первый вызов cancel — сигнал отправляется
    fmt.Println("Вызов cancel() первый раз")
    cancel()
    time.Sleep(50 * time.Millisecond) // Даём время на обработку

    // Повторные вызовы — безопасны и не влияют на состояние
    fmt.Println("Вызов cancel() второй раз")
    cancel()
    fmt.Println("Вызов cancel() третий раз")
    cancel()

    wg.Wait()
}

Вывод программы будет следующим:

Вызов cancel() первый раз
Горутина получила сигнал от ctx.Done()
Ошибка контекста: context canceled
Вызов cancel() второй раз
Вызов cancel() третий раз

Как видно, после первого вызова канал Done() уже закрыт, и горутина завершила ожидание. Дополнительные вызовы cancel() не создают новых событий.

Почему это безопасно и важно?

Идемпотентность функции cancel() критична для практического использования:

• Предотвращение паники в сценариях, где несколько компонентов системы могут пытаться завершить один контекст (например, при обработке ошибок в разных горутинах).
• Упрощение конкурентного управления ресурсами — не нужно защищать вызов cancel() мьютексом.
• Консистентность состояния: контекст после отмены остаётся в стабильном состоянии, его метод Err() всегда возвращает context.Canceled.

Типичный сценарий использования

Обычно CancelFunc передаётся в несколько горутин или функций, и любая из них может вызвать отмену при определённом условии (ошибка, timeout, внешний сигнал). Благодаря безопасному повторному вызову, нет необходимости координировать, кто именно должен вызвать cancel() — это можно делать из любого места.

func process(ctx context.Context) {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel() // Гарантирует отмену при выходе из функции, даже если уже была вызвана ранее

    go monitorErrors(cancel)
    go monitorUserInterrupt(cancel)

    // Основная логика
    select {
    case <-ctx.Done():
        return
    case result := <-compute():
        handleResult(result)
    }
}

В этом примере cancel() может быть вызвана из monitorErrors, monitorUserInterrupt или из defer при нормальном завершении process. Все вызовы безопасны.

Заключение

Таким образом, повторный вызов CancelFunc в Go является полностью безопасной идемпотентной операцией. Первый вызов устанавливает состояние контекста в "canceled" и закрывает канал Done(), а все последующие вызовы игнорируются. Это свойство фундаментально для построения надежных конкурентных систем, где отмена контекста может происходить из множества точек и не требует сложной координации.