AI Потоки, горутины, синхронизация и мьютексы в Go

[AI]

Потому что 42...

Go (Golang) создан для эффективной параллельной и конкурентной работы. Его killer feature — легковесные потоки выполнения, называемые горутины (goroutines), и мощные средства синхронизации. Приглашаю разобраться подробно.

1. Что такое горутины и как они соотносятся с потоками?

• 
  Обычные потоки (threads):
  В большинстве языков потоки создаются ОС, они "тяжёлые" (создание/переключение = дорого).
  
  
• 
  Горутины (goroutines), это такой костыль go:
  Это "зелёные" потоки Go — намного легче, чем системные потоки, планируются рантаймом Go (runtime).
  На одном системном потоке могут работать тысячи горутин.
  

Создать горутину — просто:

go myFunc() // вызовет функцию в отдельной горутине

Важно:

• 
  Горутины могут выполняться параллельно, если Go-программа запущена на многоядерном CPU.
  
  
• 
  Количество системных потоков регулирует планировщик Go (через GOMAXPROCS).
  

2. Проблема гонки данных (data race) и необходимость синхронизации


Если несколько горутин одновременно пишут/читают одну переменную — возникает гонка данных (data race). Это приводит к непредсказуемому поведению.

Пример гонки:

var counter int

go func() { counter++ }()
go func() { counter++ }()


Может случиться, что обе горутины увидят старое значение и запишут одинаковое новое.

3. Основные способы синхронизации данных в Go

A) Мьютексы (Mutex)


Мьютекс (mutual exclusion) — классическая примитивная блокировка.
В Go — тип sync.Mutex.

Применение:

import "sync"

var mu sync.Mutex
var counter int

func inc() {
mu.Lock()
counter++
mu.Unlock()
}

• 
  Только одна горутина в критической секции (между Lock() и Unlock()).
  
  
• 
  Важно: Всегда Unlock после Lock, иначе — deadlock!
  

В Go (как и в других языках), deadlock (взаимоблокировка) — это ситуация, при которой горутины навсегда застревают, ожидая друг друга или ресурсы, которые никогда не освободятся. В результате программа зависает и не может продолжить выполнение.
​

Что такое deadlock в Go


Deadlock возникает, когда:

• 
  Горутина ждет данные из канала, в который никто не пишет.
  
  
• 
  Несколько горутин ждут друг друга через каналы.
  
  
• 
  Мьютексы (или другие примитивы синхронизации) захвачены в таком порядке, что ресурсы никогда не освобождаются.
  

B) RWMutex


sync.RWMutex — позволяет нескольким читателям заходить одновременно, но писатель — только один и блокирует всех читателей.

var mu sync.RWMutex

// Для чтения
mu.RLock()
// ... читать ...
mu.RUnlock()

// Для записи
mu.Lock()
// ... писать ...
mu.Unlock()

C) Каналы (Channels)


Go-путь: синхронизация через обмен сообщениями, а не через блокировки.

ch := make(chan int)

go func() {
ch <- 42 // записать в канал (может заблокироваться)
}()

val := <-ch // получить из канала (может заблокироваться)

• 
  Канал может быть буферизированным или нет.
  
  
• 
  Позволяет строить очереди, worker pool, сигнализацию завершения.
  

D) sync/Atomic


Для простых операций над числами — атомарные операции (без мьютексов).

import "sync/atomic"

var counter int64

atomic.AddInt64(&counter, 1)
val := atomic.LoadInt64(&counter)

• 
  Быстрее, чем мьютексы, но только для примитивов (int, uint, pointer).
  
  
• 
  Не лучший вариант строить сложную логику через атомики
  

E) sync.WaitGroup


Используется для ожидания завершения группы горутин.

var wg sync.WaitGroup

wg.Add(2)
go func() {
defer wg.Done()
// ...
}()
go func() {
defer wg.Done()
// ...
}()
wg.Wait() // ждать завершения обеих горутин

F) sync.Once


Гарантирует, что функция будет вызвана ровно один раз (например, для инициализации singleton).

var once sync.Once

once.Do(func() {
// инициализация
})

G) sync.Cond


Сложный, низкоуровневый механизм для организации очередей, сигнализации.

4. Часто используемые пакеты

• 
  sync — мьютексы, RWMutex, Once, WaitGroup, Cond, Pool
  
  
• 
  sync/atomic — атомарные операции над числами и указателями
  
  
• 
  context — управление жизненным циклом (отмена/таймаут для горутин)
  
  
• 
  runtime — низкоуровневое управление планировщиком (например, GOMAXPROCS)
  
  
• 
  time — таймеры, Ticker для периодических событий
  

5. Пример: потокобезопасный counter


Рассмотрим три варианта:

1. С мьютексом


package main

import (
"fmt"
"sync"
)

type SafeCounter struct {
mu sync.Mutex
value int
}

func (c *SafeCounter) Inc() {
c.mu.Lock()
c.value++
c.mu.Unlock()
}

func (c *SafeCounter) Value() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.value
}

func main() {
counter := &SafeCounter{}
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
counter.Inc()
wg.Done()
}()
}
wg.Wait()
fmt.Println("Final value:", counter.Value())
}

2. С атомиками


package main

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

type AtomicCounter struct {
value int64
}

func (c *AtomicCounter) Inc() {
atomic.AddInt64(&c.value, 1)
}

func (c *AtomicCounter) Value() int64 {
return atomic.LoadInt64(&c.value)
}

func main() {
counter := &AtomicCounter{}
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
counter.Inc()
wg.Done()
}()
}
wg.Wait()
fmt.Println("Final value:", counter.Value())
}

3. Через канал (Go way)


package main

import (
"fmt"
"sync"
)

type ChanCounter struct {
ch chan int
value int
}

func NewChanCounter() *ChanCounter {
c := &ChanCounter{
ch: make(chan int),
}
go c.run()
return c
}

func (c *ChanCounter) run() {
for v := range c.ch {
c.value += v
}
}

func (c *ChanCounter) Inc() {
c.ch <- 1
}

func (c *ChanCounter) Close() {
close(c.ch)
}

func (c *ChanCounter) Value() int {
return c.value
}

func main() {
counter := NewChanCounter()
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
counter.Inc()
wg.Done()
}()
}
wg.Wait()
counter.Close()
fmt.Println("Final value:", counter.Value())
}

6. Советы и best practices

• 
  Мьютексы — используйте для защиты сложных структур, если нет необходимости в высокой скорости.
  
  
• 
  Атомики — для простых счётчиков, флагов и т.п.
  
  
• 
  RWMutex — если у вас много читателей и мало писателей.
  
  
• 
  Каналы — для построения concurrent pipeline, очередей и worker pool.
  
  
• 
  WaitGroup — всегда для ожидания завершения группы горутин.
  
  
• 
  Context — для управления отменой и таймаутами.
  

7. Частые ошибки

• 
  Не забыли Unlock после Lock? Используйте defer.
  
  
• 
  Не делайте сложную бизнес-логику через атомики.
  
  
• 
  Не используйте глобальные переменные без защиты!
  
  
• 
  Не закрывайте канал, если кто-то еще пишет в него.
  

8. Заключение


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