Как обработать результат выполнения 5 параллельных горутин?

Обработка результатов выполнения параллельных горутин в Go

Обработка результатов выполнения нескольких параллельных горутин — одна из ключевых задач конкурентного программирования в Go. Вот основные подходы и лучшие практики для работы с 5 параллельными горутинами.

Основные подходы

1. Использование каналов (channels)

Каналы — это типизированные конвейеры для связи между горутинами. Для 5 горутин можно использовать несколько стратегий:

package main

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

func worker(id int, resultChan chan<- int) {
    // Имитация работы
    time.Sleep(time.Millisecond * time.Duration(id*100))
    resultChan <- id * 10
}

func main() {
    const numWorkers = 5
    resultChan := make(chan int, numWorkers)
    
    // Запуск горутин
    for i := 0; i < numWorkers; i++ {
        go worker(i, resultChan)
    }
    
    // Сбор результатов
    for i := 0; i < numWorkers; i++ {
        result := <-resultChan
        fmt.Printf("Получен результат: %d\n", result)
    }
    close(resultChan)
}

2. Синхронизация с WaitGroup и сбор в срез

Комбинация sync.WaitGroup и среза для результатов — популярный подход:

func processWithWaitGroup() {
    const numWorkers = 5
    var wg sync.WaitGroup
    results := make([]int, numWorkers)
    
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            // Выполнение работы
            results[id] = id * 100
        }(i)
    }
    
    wg.Wait() // Ожидаем завершения всех горутин
    
    // Обработка результатов
    for i, result := range results {
        fmt.Printf("Горутина %d: %d\n", i, result)
    }
}

Продвинутые стратегии

3. Обработка с контекстом и таймаутами

Для контроля времени выполнения и graceful shutdown:

func processWithContext() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
    
    resultChan := make(chan int, 5)
    errChan := make(chan error, 5)
    
    for i := 0; i < 5; i++ {
        go func(id int) {
            select {
            case <-ctx.Done():
                errChan <- ctx.Err()
                return
            default:
                // Работа с контекстом
                if ctx.Err() != nil {
                    return
                }
                resultChan <- id * 10
            }
        }(i)
    }
    
    // Сбор результатов с таймаутом
    for i := 0; i < 5; i++ {
        select {
        case result := <-resultChan:
            fmt.Printf("Результат: %d\n", result)
        case err := <-errChan:
            fmt.Printf("Ошибка: %v\n", err)
        case <-ctx.Done():
            fmt.Println("Таймаут!")
            return
        }
    }
}

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

Для неблокирующего чтения из нескольких каналов:

func multiplexedProcessing() {
    chans := make([]chan int, 5)
    
    // Создаем каналы и запускаем горутины
    for i := 0; i < 5; i++ {
        chans[i] = make(chan int, 1)
        go func(id int, ch chan<- int) {
            ch <- id * 42
            close(ch)
        }(i, chans[i])
    }
    
    // Мультиплексирование результатов
    for completed := 0; completed < 5; {
        for i, ch := range chans {
            select {
            case result, ok := <-ch:
                if ok {
                    fmt.Printf("Канал %d: %d\n", i, result)
                    completed++
                }
            default:
                // Продолжаем проверять другие каналы
            }
        }
        time.Sleep(10 * time.Millisecond)
    }
}

Лучшие практики и рекомендации

Обработка ошибок

Всегда предусматривайте механизм обработки ошибок:

type Result struct {
    Value int
    Error error
}

func processWithErrorHandling() {
    resultChan := make(chan Result, 5)
    
    for i := 0; i < 5; i++ {
        go func(id int) {
            // Имитация работы с возможной ошибкой
            if id == 2 {
                resultChan <- Result{Error: fmt.Errorf("ошибка в горутине %d", id)}
                return
            }
            resultChan <- Result{Value: id * 10}
        }(i)
    }
    
    for i := 0; i < 5; i++ {
        result := <-resultChan
        if result.Error != nil {
            fmt.Printf("Ошибка: %v\n", result.Error)
        } else {
            fmt.Printf("Успех: %d\n", result.Value)
        }
    }
}

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

• Используйте буферизированные каналы при известном количестве результатов
• Применяйте пулы горутин (worker pools) для больших объемов задач
• Рассмотрите паттерн fan-out/fan-in для распределения и агрегации результатов

Архитектурные соображения

1. Разделение ответственности: Отделите запуск горутин от обработки результатов
2. Graceful shutdown: Всегда предусматривайте корректное завершение
3. Мониторинг: Добавляйте метрики выполнения для отладки
4. Ограничение ресурсов: Используйте семафоры или каналы-ограничители

Выбор подхода

Для 5 параллельных горутин наиболее эффективны:

1. Простой случай: WaitGroup + срез результатов
2. Нужен контроль времени: Контекст с таймаутами
3. Сложная логика обработки: Структурированные каналы с типами-обертками
4. Критическая производительность: Буферизированные каналы с предварительным аллокацией

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