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

Основные структуры для передачи данных между горутинами в Go

В Go для безопасной передачи данных между горутинами используется несколько ключевых структур данных, которые обеспечивают синхронизацию и предотвращают состояние гонки (race condition). Вот основные из них:

1. Каналы (Channels) - основной механизм

Каналы - это типизированные конвейеры для связи между горутинами, реализующие парадигму "общающихся последовательных процессов" (CSP). Они являются наиболее идиоматичным способом передачи данных.

// Создание небуферизованного канала
ch := make(chan int)

// Горутина-отправитель
go func() {
    ch <- 42 // Отправка данных
}()

// Горутина-получатель
value := <-ch // Получение данных

Буферизованные каналы позволяют хранить несколько значений:

// Канал с буфером на 3 элемента
ch := make(chan string, 3)

ch <- "first"
ch <- "second"
ch <- "third"

fmt.Println(<-ch) // "first"

2. Синхронизированные структуры из пакета sync

sync.Mutex и sync.RWMutex

Используются для защиты общих данных при чтении и записи:

var (
    mu    sync.Mutex
    data  map[string]int
)

// Запись с мьютексом
go func() {
    mu.Lock()
    defer mu.Unlock()
    data["key"] = 42
}()

// Чтение с мьютексом
go func() {
    mu.Lock()
    defer mu.Unlock()
    value := data["key"]
}()

sync.RWMutex позволяет множественное чтение при исключительной записи:

var (
    rwMu  sync.RWMutex
    cache map[int]string
)

// Множественные читатели могут работать одновременно
go func() {
    rwMu.RLock()
    defer rwMu.RUnlock()
    _ = cache[1]
}()

// Писатель блокирует всех
go func() {
    rwMu.Lock()
    defer rwMu.Unlock()
    cache[1] = "new value"
}()

sync.WaitGroup

Для ожидания завершения группы горутин:

var wg sync.WaitGroup

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        // Выполнение работы
    }(i)
}

wg.Wait() // Ожидание всех горутин

3. Атомарные операции (sync/atomic)

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

import "sync/atomic"

var counter int64

// Атомарное увеличение счетчика
go func() {
    atomic.AddInt64(&counter, 1)
}()

// Атомарное чтение
value := atomic.LoadInt64(&counter)

4. sync.Map - специализированная конкурентная мапа

Оптимизирована для случаев, когда ключи не изменяются часто:

var m sync.Map

// Сохранение
m.Store("key", "value")

// Загрузка
if value, ok := m.Load("key"); ok {
    fmt.Println(value)
}

// Конкурентное использование из многих горутин
go func() {
    m.Store("goroutine1", "data1")
}()

5. Контексты (context.Context)

Для передачи сигналов отмены, дедлайнов и значений через границы горутин:

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// Передача контекста в горутину
go func(ctx context.Context) {
    select {
    case <-ctx.Done():
        // Обработка отмены или таймаута
        return
    case <-time.After(10 * time.Second):
        // Долгая операция
    }
}(ctx)

6. Select с несколькими каналами

Паттерн для работы с несколькими каналами одновременно:

select {
case msg := <-ch1:
    // Обработка сообщения из ch1
case data := <-ch2:
    // Обработка сообщения из ch2
case <-time.After(1 * time.Second):
    // Таймаут
default:
    // Неблокирующая операция
}

Критерии выбора структуры

• Каналы - для передачи владения данными и потоковой обработки
• Мьютексы - для защиты общих структур в памяти
• sync.Map - для read-heavy workloads с редкими записями
• Атомарные операции - для простых счетчиков и флагов
• WaitGroup - для координации завершения горутин
• Контексты - для передачи сигналов управления

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

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

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