Как реализовано управление тредами в Golang?

Управление потоками (Goroutines) в Go

В Go управление потоками реализовано принципиально иначе, чем классические потоки операционной системы (OS threads). Вместо прямого использования системных тредов Go оперирует концепцией горутин (goroutines) — легковесных потоков, управляемых средой выполнения Go (runtime), а не ОС.

Основные принципы реализации

Горутины — это функции или методы, выполняющиеся конкурентно с другими горутинами в том же адресном пространстве. Их ключевые особенности:

• Легковесность: Размер стека начинается с 2 КБ (против ~1-2 МБ у OS thread) и динамически растёт/сокращается.
• Быстрое создание и уничтожение: Накладные расходы на создание значительно ниже.
• Мультиплексирование на OS threads: Множество горутин выполняется на меньшем количестве системных потоков.

Архитектура планировщика (Scheduler)

Управление горутинами осуществляет встроенный планировщик Go (scheduler), который является кооперативным (cooperative) с элементами вытеснения (preemption). Он использует модель M:N (many-to-many), где M горутин планируются на N OS threads.

Ключевые компоненты планировщика:

• M (Machine): Представляет OS thread. Управляется ОС.
• G (Goroutine): Представляет саму горутину. Содержит стек, указатель инструкций и другую информацию о состоянии.
• P (Processor): Виртуальный процессор или контекст планировщика. Связывает M и G. Хранит локальную очередь исполняемых горутин (runqueue). Количество P обычно равно GOMAXPROCS (по умолчанию — количество логических CPU).

// Пример создания горутин
package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    // Запуск двух горутин
    go say("горутина 1")
    go say("горутина 2")
    
    // Даём время на выполнение
    time.Sleep(1 * time.Second)
    fmt.Println("Основной поток завершён.")
}

Механизмы управления и синхронизации

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

1. Каналы (channels) — типобезопасный способ передачи данных между горутинами. Обеспечивают синхронизацию по принципу «общайся через общую память, а делись памятью через общение» (Do not communicate by sharing memory; instead, share memory by communicating).

   ch := make(chan int, 2) // Буферизированный канал
   go func() { ch <- 42 }()
   value := <-ch // Синхронное получение
   

2. Примитивы синхронизации из пакета sync:

    *   **`sync.Mutex`** и **`sync.RWMutex`** для исключительного доступа к общим данным.
    *   **`sync.WaitGroup`** для ожидания завершения группы горутин.
    *   **`sync.Once`** для однократного выполнения.
    *   **`sync.Pool`** для пулов повторно используемых объектов.

```go
var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}
```

3. Вытеснение (Preemption): Начиная с Go 1.14, планировщик реализует асинхронное вытеснение на основе сигналов ОС, что предотвращает «голодание» других горутин, если одна выполняет длительные вычисления без точек вытеснения.

Жизненный цикл горутины

1. Создание через ключевое слово go.
2. Помещение в локальную очередь P или глобальную очередь.
3. Исполнение на OS thread (M), привязанном к P.
4. Блокировка при операциях ввода-вывода, системных вызовах, ожидании канала или мьютекса. При блокировке горутина снимается с M, что позволяет использовать поток для других задач.
5. Завершение при выходе из функции. Освобождённые ресурсы возвращаются в пулы для повторного использования.

Преимущества подхода Go

• Высокая производительность при массовом параллелизме: Можно создавать сотни тысяч горутин без значительных накладных расходов.
• Эффективное использование ресурсов CPU: Планировщик активно перераспределяет горутины между потоками.
• Упрощённая модель программирования: Абстракция горутин и каналов позволяет писать чистый конкурентный код без низкоуровневых операций с потоками.
• Интеграция с системным вводом-выводом: Сеть и файловые операции используют асинхронные системные вызовы, что позволяет эффективно обрабатывать множество одновременных операций I/O.

Отличия от классических потоков

Таким образом, управление потоками в Go через горутины и планировщик runtime представляет собой высокоуровневую абстракцию, которая обеспечивает эффективный конкурентный и параллельный код, скрывая сложности ручного управления системными потоками, блокировками и синхронизацией. Это одна из ключевых фич языка, делающая его особенно подходящим для разработки высоконагруженных сетевых сервисов и распределённых систем.