Как написать context.Background?

Использование context.Background() в Go

context.Background() — это фундаментальная функция в пакете context языка Go, которая возвращает "пустой" или корневой контекст. Этот контекст никогда не отменяется, не имеет дедлайна и не содержит значений. Он служит отправной точкой для создания производных контекстов.

Основное назначение и использование

package main

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

func main() {
    // Создание корневого контекста
    ctx := context.Background()
    
    // Создание производного контекста с таймаутом
    ctxWithTimeout, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()
    
    // Использование контекста в функции
    result, err := longRunningOperation(ctxWithTimeout)
    if err != nil {
        fmt.Println("Ошибка:", err)
    } else {
        fmt.Println("Результат:", result)
    }
}

func longRunningOperation(ctx context.Context) (string, error) {
    select {
    case <-time.After(3 * time.Second):
        return "Успешно завершено", nil
    case <-ctx.Done():
        return "", ctx.Err()
    }
}

Ключевые особенности context.Background()

1. Корневой контекст — всегда должен быть точкой входа для создания цепочки контекстов
2. Не отменяется — в отличие от context.TODO(), его использование явно указывает на намерение
3. Без дедлайна — не имеет временных ограничений по умолчанию
4. Без значений — не содержит key-value пар

Когда использовать context.Background()

• В функции main() — как отправная точка для всего приложения:

func main() {
    ctx := context.Background()
    // Инициализация сервисов с передачей контекста
    startServer(ctx)
}

• В тестах — когда нужен чистый контекст:

func TestMyFunction(t *testing.T) {
    ctx := context.Background()
    result := MyFunction(ctx, testData)
    // Проверки результата
}

• В инициализации — при запуске фоновых процессов:

func initWorker() {
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)
    go worker(ctx)
    // cancel() будет вызвана при завершении
}

Отличия от context.TODO()

Важно различать context.Background() и context.TODO():

// Background - используется, когда вы уверены, что нужен корневой контекст
func processRequest() error {
    ctx := context.Background()
    ctx = context.WithValue(ctx, "requestID", generateID())
    return handle(ctx)
}

// TODO - используется как заглушка, когда неясно какой контекст нужен
func oldFunction(param string) {
    // Будет переписана позже с правильным контекстом
    ctx := context.TODO()
    // временная реализация
}

Практические паттерны использования

1. Создание цепочек контекстов:

func handleHTTPRequest(w http.ResponseWriter, r *http.Request) {
    // Корневой контекст
    ctx := context.Background()
    
    // Добавляем таймаут для всей операции
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()
    
    // Добавляем кастомные значения
    ctx = context.WithValue(ctx, "userIP", r.RemoteAddr)
    
    // Передаем в бизнес-логику
    processUserRequest(ctx)
}

1. Для горутин с отменой:

func startService() {
    ctx := context.Background()
    ctx, stopService := context.WithCancel(ctx)
    
    go func() {
        <-someShutdownSignal
        stopService() // Отмена всех зависимых операций
    }()
    
    runService(ctx)
}

1. В работе с базами данных:

func queryDatabase() {
    ctx := context.Background()
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
    
    rows, err := db.QueryContext(ctx, "SELECT * FROM users")
    if err != nil {
        // Автоматическая отмена при таймауте
        log.Fatal(err)
    }
    defer rows.Close()
}

Важные рекомендации

1. Не передавайте nil вместо контекста — всегда используйте context.Background() или производный контекст
2. Правильно обрабатывайте отмену — всегда вызывайте defer cancel() для контекстов с отменой
3. Пробрасывайте контекст через все уровни — от HTTP-обработчиков до низкоуровневых вызовов
4. Используйте WithValue осторожно — только для request-scoped данных, не для передачи зависимостей

Контекст в Go — это мощный механизм для управления временем жизни операций, отмены и передачи метаданных. context.Background() является фундаментальным строительным блоком этой системы, обеспечивая чистую отправную точку для всех операций, требующих контекста. Правильное использование контекстов значительно улучшает надежность и управляемость Go-приложений, особенно в распределенных системах.