Home » Как использовать контексты в Go — управление потоком выполнения

Как использовать контексты в Go — управление потоком выполнения

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

Контексты особенно важны для тех, кто разрабатывает и обслуживает серверные приложения — от простых HTTP-серверов до сложных микросервисов. Они помогают избежать утечек ресурсов, корректно обрабатывать отмену операций и устанавливать таймауты. Если вы настраиваете серверную инфраструктуру, понимание контекстов поможет вам создавать более надёжные и производительные приложения.

Что такое контекст и как он работает

Контекст в Go — это интерфейс, который позволяет передавать сигналы отмены, таймауты и другие request-scoped значения через границы API и между горутинами. Проще говоря, это способ сказать вашему коду: “Хватит работать, пора остановиться”.

Основные возможности контекстов:

Отмена операций — остановка выполнения при получении сигнала отмены
Таймауты — автоматическая отмена операций по истечении времени
Дедлайны — завершение операций к определённому моменту времени
Передача значений — хранение request-scoped данных

Контекст — это дерево. Каждый дочерний контекст может быть отменён независимо, но отмена родительского контекста автоматически отменяет все дочерние.

Базовая настройка и первые шаги

Начнём с простого примера HTTP-сервера, который использует контексты для управления таймаутами:

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Сервер запущен на порту 8080")
    http.ListenAndServe(":8080", nil)
}

func handler(w http.ResponseWriter, r *http.Request) {
    // Создаём контекст с таймаутом в 5 секунд
    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
    defer cancel() // Важно! Всегда вызываем cancel
    
    // Симулируем долгую операцию
    result := make(chan string, 1)
    go func() {
        time.Sleep(3 * time.Second) // Работаем 3 секунды
        result <- "Операция завершена"
    }()
    
    select {
    case <-ctx.Done():
        http.Error(w, "Таймаут запроса", http.StatusRequestTimeout)
        return
    case res := <-result:
        fmt.Fprintf(w, res)
    }
}

Этот пример показывает основной паттерн использования контекстов. Создаём контекст с таймаутом, запускаем операцию в горутине и ждём либо её завершения, либо отмены контекста.

Типы контекстов и их применение

Go предоставляет несколько функций для создания контекстов:

Функция	Назначение	Когда использовать
`context.Background()`	Пустой контекст	Корневой контекст для main, init, тестов
`context.TODO()`	Заглушка	Когда не уверены, какой контекст использовать
`context.WithCancel()`	Контекст с отменой	Ручная отмена операций
`context.WithTimeout()`	Контекст с таймаутом	Автоматическая отмена через время
`context.WithDeadline()`	Контекст с дедлайном	Отмена в конкретное время
`context.WithValue()`	Контекст со значениями	Передача request-scoped данных

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

package main

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

func main() {
    // WithCancel — ручная отмена
    ctx1, cancel1 := context.WithCancel(context.Background())
    go worker(ctx1, "Worker 1")
    time.Sleep(2 * time.Second)
    cancel1() // Отменяем вручную
    
    // WithTimeout — автоматическая отмена
    ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel2()
    go worker(ctx2, "Worker 2")
    
    // WithDeadline — отмена в конкретное время
    deadline := time.Now().Add(1 * time.Second)
    ctx3, cancel3 := context.WithDeadline(context.Background(), deadline)
    defer cancel3()
    go worker(ctx3, "Worker 3")
    
    // WithValue — передача значений
    ctx4 := context.WithValue(context.Background(), "userID", "12345")
    processRequest(ctx4)
    
    time.Sleep(5 * time.Second)
}

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("%s остановлен: %v\n", name, ctx.Err())
            return
        default:
            fmt.Printf("%s работает...\n", name)
            time.Sleep(500 * time.Millisecond)
        }
    }
}

func processRequest(ctx context.Context) {
    userID := ctx.Value("userID").(string)
    fmt.Printf("Обрабатываем запрос для пользователя: %s\n", userID)
}

Практические примеры для серверных приложений

Вот несколько реальных сценариев использования контекстов, которые пригодятся при работе с серверами:

HTTP-клиент с таймаутом

package main

import (
    "context"
    "fmt"
    "io"
    "net/http"
    "time"
)

func fetchWithTimeout(url string, timeout time.Duration) (string, error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()
    
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return "", err
    }
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }
    
    return string(body), nil
}

func main() {
    // Попробуем получить данные с таймаутом в 2 секунды
    result, err := fetchWithTimeout("https://httpbin.org/delay/1", 2*time.Second)
    if err != nil {
        fmt.Printf("Ошибка: %v\n", err)
        return
    }
    fmt.Printf("Результат: %s\n", result)
}

База данных с контекстом

package main

import (
    "context"
    "database/sql"
    "fmt"
    "time"
    
    _ "github.com/lib/pq"
)

type User struct {
    ID   int
    Name string
}

func getUserWithTimeout(db *sql.DB, userID int, timeout time.Duration) (*User, error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()
    
    query := "SELECT id, name FROM users WHERE id = $1"
    row := db.QueryRowContext(ctx, query, userID)
    
    var user User
    err := row.Scan(&user.ID, &user.Name)
    if err != nil {
        return nil, err
    }
    
    return &user, nil
}

func main() {
    db, err := sql.Open("postgres", "host=localhost user=myuser dbname=mydb sslmode=disable")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    user, err := getUserWithTimeout(db, 1, 5*time.Second)
    if err != nil {
        fmt.Printf("Ошибка получения пользователя: %v\n", err)
        return
    }
    
    fmt.Printf("Пользователь: %+v\n", user)
}

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

Graceful shutdown сервера

Один из самых важных паттернов для серверных приложений — корректное завершение работы:

package main

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    // Создаём HTTP-сервер
    server := &http.Server{
        Addr:    ":8080",
        Handler: http.HandlerFunc(handler),
    }
    
    // Запускаем сервер в горутине
    go func() {
        fmt.Println("Сервер запущен на порту 8080")
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            fmt.Printf("Ошибка сервера: %v\n", err)
        }
    }()
    
    // Ждём сигнал завершения
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    fmt.Println("Получен сигнал завершения, останавливаем сервер...")
    
    // Graceful shutdown с таймаутом
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    if err := server.Shutdown(ctx); err != nil {
        fmt.Printf("Ошибка при завершении сервера: %v\n", err)
    }
    
    fmt.Println("Сервер остановлен")
}

func handler(w http.ResponseWriter, r *http.Request) {
    // Симулируем долгую операцию
    time.Sleep(2 * time.Second)
    fmt.Fprintf(w, "Запрос обработан")
}

Мониторинг и отмена множественных операций

package main

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

func main() {
    // Создаём контекст с отменой
    ctx, cancel := context.WithCancel(context.Background())
    
    var wg sync.WaitGroup
    
    // Запускаем несколько воркеров
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            worker(ctx, fmt.Sprintf("Worker-%d", id))
        }(i)
    }
    
    // Через 3 секунды отменяем все операции
    time.Sleep(3 * time.Second)
    fmt.Println("Отменяем все операции...")
    cancel()
    
    // Ждём завершения всех воркеров
    wg.Wait()
    fmt.Println("Все воркеры завершены")
}

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("%s: получен сигнал отмены\n", name)
            return
        default:
            fmt.Printf("%s: работаю...\n", name)
            time.Sleep(500 * time.Millisecond)
        }
    }
}

Распространённые ошибки и как их избежать

Вот список типичных ошибок при работе с контекстами и способы их решения:

Ошибка	Проблема	Решение
Забыли вызвать `cancel()`	Утечка ресурсов	Всегда используйте `defer cancel()`
Передача `nil` контекста	Панические ошибки	Используйте `context.Background()` или `context.TODO()`
Хранение контекста в структуре	Неправильный дизайн API	Передавайте контекст как первый параметр функции
Использование `WithValue` для обязательных данных	Скрытые зависимости	Передавайте важные данные как параметры функций

Пример правильного и неправильного использования

// ❌ Неправильно
type Handler struct {
    ctx context.Context
}

func (h *Handler) Process() {
    // Контекст в структуре — плохая практика
}

// ✅ Правильно
type Handler struct {
    // Другие поля
}

func (h *Handler) Process(ctx context.Context) {
    // Контекст как параметр — хорошая практика
}

// ❌ Неправильно
func badFunction() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    // Забыли defer cancel() — утечка ресурсов
    
    doSomething(ctx)
}

// ✅ Правильно
func goodFunction() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel() // Всегда освобождаем ресурсы
    
    doSomething(ctx)
}

Интеграция с популярными библиотеками

Контексты отлично работают с популярными Go-библиотеками:

Gin Framework

package main

import (
    "context"
    "net/http"
    "time"
    
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    
    r.GET("/api/data", func(c *gin.Context) {
        // Используем контекст из Gin
        ctx := c.Request.Context()
        
        // Добавляем таймаут
        ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
        defer cancel()
        
        // Вызываем бизнес-логику
        data, err := fetchData(ctx)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        
        c.JSON(http.StatusOK, data)
    })
    
    r.Run(":8080")
}

func fetchData(ctx context.Context) (map[string]interface{}, error) {
    // Симулируем работу с базой или API
    select {
    case <-time.After(2 * time.Second):
        return map[string]interface{}{"message": "success"}, nil
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

gRPC

// server.go
func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    // Проверяем, не отменён ли контекст
    if ctx.Err() != nil {
        return nil, ctx.Err()
    }
    
    // Используем контекст для работы с базой
    user, err := s.db.GetUserByID(ctx, req.UserId)
    if err != nil {
        return nil, err
    }
    
    return &pb.User{
        Id:   user.ID,
        Name: user.Name,
    }, nil
}

Мониторинг и диагностика

Для отладки контекстов полезно логировать их состояние:

package main

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

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
    
    // Запускаем мониторинг контекста
    go monitorContext(ctx)
    
    // Симулируем работу
    time.Sleep(3 * time.Second)
}

func monitorContext(ctx context.Context) {
    ticker := time.NewTicker(500 * time.Millisecond)
    defer ticker.Stop()
    
    for {
        select {
        case <-ctx.Done():
            log.Printf("Контекст отменён: %v", ctx.Err())
            return
        case <-ticker.C:
            if deadline, ok := ctx.Deadline(); ok {
                remaining := time.Until(deadline)
                log.Printf("До дедлайна осталось: %v", remaining)
            }
        }
    }
}

Производительность и оптимизация

Контексты имеют минимальные накладные расходы, но есть несколько моментов для оптимизации:

Переиспользование контекстов — не создавайте новые контексты без необходимости
Правильное время жизни — отменяйте контексты как можно раньше
Избегайте глубокого нестинга — слишком много уровней контекстов могут замедлить работу

Альтернативы и сравнения

До появления контекстов в Go использовались другие подходы:

Каналы — всё ещё актуальны для простых случаев
sync.WaitGroup — для ожидания завершения горутин
time.Timer — для таймаутов

Контексты объединяют всё это в единый удобный API.

Автоматизация и DevOps

Контексты отлично подходят для создания инструментов автоматизации. Вот пример скрипта для мониторинга серверов:

package main

import (
    "context"
    "fmt"
    "net/http"
    "sync"
    "time"
)

type Server struct {
    Name string
    URL  string
}

func main() {
    servers := []Server{
        {"Web Server", "http://localhost:8080/health"},
        {"API Server", "http://localhost:8081/health"},
        {"Database", "http://localhost:5432/health"},
    }
    
    // Создаём контекст с таймаутом для всей проверки
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    var wg sync.WaitGroup
    results := make(chan string, len(servers))
    
    // Проверяем каждый сервер параллельно
    for _, server := range servers {
        wg.Add(1)
        go func(s Server) {
            defer wg.Done()
            checkServer(ctx, s, results)
        }(server)
    }
    
    // Ждём завершения всех проверок
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // Собираем результаты
    for result := range results {
        fmt.Println(result)
    }
}

func checkServer(ctx context.Context, server Server, results chan<- string) {
    // Создаём запрос с контекстом
    req, err := http.NewRequestWithContext(ctx, "GET", server.URL, nil)
    if err != nil {
        results <- fmt.Sprintf("❌ %s: ошибка создания запроса", server.Name)
        return
    }
    
    client := &http.Client{Timeout: 5 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        results <- fmt.Sprintf("❌ %s: недоступен", server.Name)
        return
    }
    defer resp.Body.Close()
    
    if resp.StatusCode == http.StatusOK {
        results <- fmt.Sprintf("✅ %s: работает", server.Name)
    } else {
        results <- fmt.Sprintf("⚠️ %s: статус %d", server.Name, resp.StatusCode)
    }
}

Деплой и тестирование

Для тестирования кода с контекстами создайте простой тестовый сервер:

go mod init context-example
go run main.go

Если вы разрабатываете серверные приложения, рекомендую использовать VPS для тестирования — https://arenda-server.cloud/vps. Для более серьёзных нагрузок подойдёт выделенный сервер — https://arenda-server.cloud/dedicated.

Интересные факты и нестандартные применения

Контексты в тестах — можно использовать для имитации отмены операций
Трассировка запросов — передача trace ID через контекст
Rate limiting — контроль частоты запросов с помощью контекстов
Circuit breaker — реализация паттерна автоматического отключения

Пример трассировки запросов:

package main

import (
    "context"
    "fmt"
    "math/rand"
    "time"
)

type TraceID string

func main() {
    // Создаём контекст с ID трассировки
    traceID := TraceID(fmt.Sprintf("trace-%d", rand.Int63()))
    ctx := context.WithValue(context.Background(), "traceID", traceID)
    
    // Передаём контекст через цепочку вызовов
    processRequest(ctx)
}

func processRequest(ctx context.Context) {
    logWithTrace(ctx, "Начинаем обработку запроса")
    
    // Передаём контекст дальше
    err := businessLogic(ctx)
    if err != nil {
        logWithTrace(ctx, "Ошибка: %v", err)
        return
    }
    
    logWithTrace(ctx, "Запрос успешно обработан")
}

func businessLogic(ctx context.Context) error {
    logWithTrace(ctx, "Выполняем бизнес-логику")
    
    // Симулируем работу
    time.Sleep(100 * time.Millisecond)
    
    return nil
}

func logWithTrace(ctx context.Context, format string, args ...interface{}) {
    traceID := ctx.Value("traceID")
    message := fmt.Sprintf(format, args...)
    fmt.Printf("[%s] %s\n", traceID, message)
}

Заключение и рекомендации

Контексты в Go — это мощный инструмент для управления жизненным циклом операций в серверных приложениях. Они помогают:

Корректно обрабатывать таймауты и отмены
Избегать утечек ресурсов
Передавать request-scoped данные
Создавать отзывчивые приложения

Когда использовать контексты:

HTTP-серверы и клиенты
Работа с базами данных
Вызовы внешних API
Долгие вычисления
Graceful shutdown

Где особенно важно:

Микросервисы
Web API
Системы мониторинга
Инструменты автоматизации

Помните основные правила: всегда вызывайте cancel(), передавайте контекст как первый параметр функции, используйте context.Background() для корневых контекстов и не храните контексты в структурах. Следуя этим простым правилам, вы сможете создавать надёжные и производительные Go-приложения.

Полезные ссылки:

В этой статье собрана информация и материалы из различных интернет-источников. Мы признаем и ценим работу всех оригинальных авторов, издателей и веб-сайтов. Несмотря на то, что были приложены все усилия для надлежащего указания исходного материала, любая непреднамеренная оплошность или упущение не являются нарушением авторских прав. Все упомянутые товарные знаки, логотипы и изображения являются собственностью соответствующих владельцев. Если вы считаете, что какой-либо контент, использованный в этой статье, нарушает ваши авторские права, немедленно свяжитесь с нами для рассмотрения и принятия оперативных мер.

Данная статья предназначена исключительно для ознакомительных и образовательных целей и не ущемляет права правообладателей. Если какой-либо материал, защищенный авторским правом, был использован без должного упоминания или с нарушением законов об авторском праве, это непреднамеренно, и мы исправим это незамедлительно после уведомления. Обратите внимание, что переиздание, распространение или воспроизведение части или всего содержимого в любой форме запрещено без письменного разрешения автора и владельца веб-сайта. Для получения разрешений или дополнительных запросов, пожалуйста, свяжитесь с нами.