Какими единицами оперирует многопоточность в Go

Единицы многопоточности в Go

В Go основными единицами для параллельного и асинхронного выполнения являются горутины (goroutines), которые работают поверх абстракции, называемой моделью параллелизма M:N, где M — это горутины, а N — это системные потоки (threads) ОС. Вместо непосредственной работы с потоками ОС, Go использует виртуальные потоки, известные как M (Machine) и P (Processor), координируемые планировщиком (scheduler). Давайте разберем каждую единицу подробно.

1. Горутина (Goroutine)

Горутина — это легковесный поток выполнения, управляемый средой выполнения Go (runtime), а не операционной системой напрямую. Она является основным строительным блоком для многопоточности в Go. Горутины создаются с помощью ключевого слова go и работают поверх модели параллелизма M:N, где множество горутин может выполняться на меньшем количестве системных потоков.

Пример создания горутины:

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // Запуск горутины
    go printNumbers()
    time.Sleep(1 * time.Second) // Даем время для выполнения
}

Горутины используют меньше памяти (2 КБ стека) по сравнению с потоками ОС (1–2 МБ), что позволяет создавать тысячи или миллионы горутин без значительных накладных расходов.

2. Системные потоки (OS Threads)

Внутренне Go runtime использует системные потоки (threads) для выполнения кода на физических процессорных ядрах. Однако программисты на Go редко взаимодействуют с потоками напрямую; вместо этого они работают через абстракцию горутин. Количество потоков ОС обычно равно количеству доступных логических процессоров (CPU cores), но может быть изменено через GOMAXPROCS.

Управление потоками:

import "runtime"

func main() {
    // Установка максимального количества потоков OS
    runtime.GOMAXPROCS(4) // Использует до 4 потоков ОС
}

GOMAXPROCS управляет количеством системных потоков, которые могут одновременно выполнять горутины.

3. Модель параллелизма: M, P, G

Для управления горутинами и системными потоками Go runtime использует внутреннюю модель с тремя компонентами:

• G (Goroutine): Представляет горутину.
• M (Machine): Абстрактный системный поток, который выполняет код Go.
• P (Processor): Контекст выполнения (или "процессор"), который управляет набором горутин и обеспечивает их выполнение на M.

Планировщик Go распределяет G на P, которые, в свою очередь, привязываются к M, выполняющимся на физических ядрах процессора. Это позволяет эффективно использовать ресурсы CPU и минимизировать блокировки и переключения контекста.

4. Каналы и примитивы синхронизации

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

• Каналы (Channels): Для безопасного обмена данными между горутинами.
• Мьютексы (Mutexes): Для защиты общих ресурсов (например, из пакета sync).
• WaitGroups: Для ожидания завершения группы горутин.

Пример с каналом:

package main

import "fmt"

func sum(a, b int, ch chan int) {
    ch <- a + b // Отправка результата в канал
}

func main() {
    ch := make(chan int)
    go sum(10, 20, ch)
    result := <-ch // Получение результата из канала
    fmt.Println(result) // Вывод: 30
}

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

Практические выводы

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

• Эффективность: Горутины легковесны и быстро создаются/уничтожаются.
• Простота: Синтаксис go и каналы делают параллельное программирование интуитивным.
• Гибкость: Модель M:P:G адаптируется к нагрузке, распределяя работу по ядрам CPU.

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