Как получать данные из одной горутины в другую?

Получение данных между горутинами в Go

В Go, как в языке с моделью параллелизма CSP (Communicating Sequential Processes), обмен данными между горутинами является фундаментальной концепцией. Основной механизм — каналы (channels), но существуют и другие подходы. Рассмотрим основные способы.

1. Каналы (Channels) — основной способ

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

Базовый пример с небуферизованным каналом

package main

import "fmt"

func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i // Отправка данных в канал
    }
    close(ch) // Закрытие канала после отправки всех данных
}

func main() {
    ch := make(chan int) // Создание небуферизованного канала
    
    go producer(ch) // Запуск горутины-производителя
    
    // Получение данных из канала в основной горутине
    for value := range ch {
        fmt.Println("Получено:", value)
    }
}

Буферизованные каналы для асинхронной работы

func main() {
    // Канал с буфером на 3 элемента
    ch := make(chan string, 3)
    
    go func() {
        messages := []string{"Hello", "World", "From", "Go"}
        for _, msg := range messages {
            ch <- msg
            fmt.Println("Отправлено:", msg)
        }
        close(ch)
    }()
    
    for msg := range ch {
        fmt.Println("Получено:", msg)
    }
}

2. Синхронизация с помощью WaitGroup и общих структур

Для более сложных сценариев можно использовать мьютексы и атомарные операции с общей памятью.

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

func main() {
    var wg sync.WaitGroup
    var counter int32
    var mu sync.Mutex
    var data []string
    
    // Горутина-писатель
    wg.Add(1)
    go func() {
        defer wg.Done()
        mu.Lock()
        data = append(data, "Hello", "World")
        mu.Unlock()
        atomic.AddInt32(&counter, 2)
    }()
    
    // Горутина-читатель
    wg.Add(1)
    go func() {
        defer wg.Done()
        mu.Lock()
        if len(data) > 0 {
            fmt.Println("Данные:", data)
        }
        mu.Unlock()
    }()
    
    wg.Wait()
    fmt.Println("Итоговый счетчик:", atomic.LoadInt32(&counter))
}

3. Select для работы с несколькими каналами

Конструкция select позволяет ожидать операции на нескольких каналах одновременно.

func worker(id int, ch chan<- string, done <-chan struct{}) {
    for i := 0; i < 3; i++ {
        select {
        case ch <- fmt.Sprintf("Worker %d: message %d", id, i):
            // Сообщение отправлено
        case <-done:
            // Получен сигнал завершения
            fmt.Printf("Worker %d завершен\n", id)
            return
        }
    }
}

func main() {
    ch := make(chan string)
    done := make(chan struct{})
    
    for i := 0; i < 3; i++ {
        go worker(i, ch, done)
    }
    
    // Получение 5 сообщений
    for i := 0; i < 5; i++ {
        fmt.Println(<-ch)
    }
    
    close(done) // Сигнал завершения всем горутинам
    time.Sleep(100 * time.Millisecond)
}

4. Контекст (Context) для управления потоком данных

Context позволяет передавать данные, сигналы отмены и дедлайны между горутинами.

func dataProcessor(ctx context.Context, dataCh <-chan int) {
    for {
        select {
        case data := <-dataCh:
            fmt.Println("Обработка данных:", data)
        case <-ctx.Done():
            fmt.Println("Контекст отменен:", ctx.Err())
            return
        }
    }
}

Ключевые рекомендации по выбору подхода:

• Используйте каналы для передачи владения данными между горутинами
• Небуферизованные каналы обеспечивают синхронную коммуникацию (отправитель ждет получателя)
• Буферизованные каналы позволяют развязать производителя и потребителя
• Select необходим для нетривиальной логики работы с несколькими каналами
• Мьютексы (sync.Mutex) используйте для защиты общих структур данных при редких операциях
• Атомарные операции (sync/atomic) эффективны для простых счетчиков и флагов
• Context — лучший способ передачи сигналов отмены и дедлайнов

Важные принципы:

1. "Не общайтесь через общую память, делитесь памятью через общение" — основная философия Go
2. Закрывайте каналы только со стороны отправителя
3. Избегайте утечек горутин — всегда предусматривайте механизмы завершения
4. Используйте панику редко — для коммуникации между горутинами используйте каналы ошибок

Правильный выбор механизма коммуникации зависит от конкретной задачи: простой поток данных эффективнее через каналы, а редкий доступ к сложной структуре — через мьютексы.