К содержимому
Войти

Go Road Map

🏃 Горутины и планировщик

Горутина — это функция, которую рантайм Go выполняет независимо от остального кода. Запускается она словом go, стоит пару килобайт памяти, и сервис на Go держит их десятки тысяч на один процесс. Распределяет горутины по потокам ОС планировщик рантайма, и от того, как он устроен, зависят задержки сервиса, число потоков и поведение в Kubernetes. Вопрос «чем горутина отличается от потока» задают почти на каждом собеседовании на Go, а следом спрашивают про модель GMP

🧠 Как это устроено

Горутина против потока ОС

Поток ОС создаёт ядро. Под его стек резервируется память фиксированного размера (в Linux обычно 8 МБ, это значение ulimit -s), а переключение между потоками идёт через ядро: сохранить регистры, сменить контекст, вернуться. Горутину создаёт и переключает рантайм Go в пространстве пользователя, без системных вызовов

Поток ОСГорутина
Кто управляетЯдроПланировщик рантайма Go
Стек на стартеФиксированный, в Linux обычно 8 МБ2 КБ, растёт по мере надобности
Предел стекаЗадан при создании1 ГБ на 64-битных системах
ПереключениеЧерез ядроВ пространстве пользователя, сохраняется несколько регистров
ИдентификаторЕсть, его видит ОСНаружу не отдаётся, получить ID горутины из кода нельзя
Сколько держит процессТысячиСотни тысяч

Стек горутины растёт копированием. Почти каждая функция в начале проверяет, хватит ли места. Не хватило, и рантайм выделяет стек в два раза больше, копирует туда старый и поправляет указатели. Поэтому глубокая рекурсия в горутине работает, а указатель на переменную в стеке всё равно остаётся корректным

Модель GMP

Планировщик оперирует тремя сущностями. Названия идут из комментария в runtime/proc.go:

  • G — горутина: стек, указатель на текущую инструкцию, состояние
  • M — поток ОС, на котором выполняется код (machine)
  • P — процессор в смысле рантайма: право выполнять Go-код и набор ресурсов к нему. Чтобы выполнять горутину, поток M обязан держать P

Число P равно GOMAXPROCS. Оно и задаёт, сколько горутин выполняется параллельно в один момент. Потоков M бывает больше: часть из них спит или ждёт системного вызова без P

У каждого P своя локальная очередь готовых горутин на 256 мест и отдельный слот runnext для горутины, которая должна пойти следующей. Кроме того, есть одна глобальная очередь на весь процесс. Локальные очереди нужны, чтобы потоки не дрались за один общий замок: в Go 1.0 очередь была одна, и на многоядерных машинах планировщик упирался в неё. Модель с P описал Дмитрий Вьюков в дизайн-документе 2012 года, в рантайм она вошла в Go 1.1

Когда P ищет, что запустить дальше, порядок примерно такой:

  1. Каждый 61-й раз сначала заглянуть в глобальную очередь, чтобы горутины оттуда не ждали вечно
  2. Взять горутину из runnext, потом из локальной очереди
  3. Взять пачку из глобальной очереди
  4. Спросить netpoller, не готовы ли сетевые соединения, и забрать проснувшиеся горутины
  5. Украсть половину очереди у другого P, выбрав его случайно. Это и есть work stealing

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

Вытеснение

До Go 1.14 вытеснение было кооперативным. Рантайм просил горутину уступить место, и она замечала просьбу только на входе в функцию, там, где проверяется размер стека. Цикл без вызовов функций мог держать P сколько угодно, мешая и другим горутинам, и сборщику мусора

С Go 1.14 вытеснение асинхронное. Фоновый поток sysmon следит за всеми P. Если горутина выполняется дольше 10 мс, он помечает её на вытеснение и посылает её потоку сигнал SIGURG. Обработчик сигнала останавливает горутину в безопасной точке и возвращает её в очередь. Проверить можно на программе с одним P:

func main() {
	runtime.GOMAXPROCS(1)
	go func() {
		for { // цикл без вызовов функций
		}
	}()
	time.Sleep(10 * time.Millisecond) // отдаём единственный P горутине с циклом
	fmt.Println("main снова работает")
}

Программа печатает main снова работает и выходит. С GODEBUG=asyncpreemptoff=1, то есть с выключенным асинхронным вытеснением, она висит, пока её не убьют: main проснулся, но P занят циклом и не освобождается

Системный вызов и сеть

Чтение файла, fsync или вызов через cgo блокируют поток в ядре. Планировщик поступает так:

  1. Горутина входит в системный вызов, поток M уходит в ядро вместе с ней. P пока остаётся за ним
  2. Если вызов длится дольше одного тика sysmon (от 20 мкс), sysmon отбирает P и отдаёт другому потоку. При необходимости рантайм создаёт новый M. Остальные горутины этого P продолжают работать
  3. Вызов вернулся. Поток пробует забрать свой прежний P, потом любой свободный. Не вышло, и горутина уходит в глобальную очередь, а поток засыпает

Отсюда следствие, которое удивляет на проде: потоков в процессе бывает намного больше, чем GOMAXPROCS. Сотня горутин, застрявших в медленном диске или в блокирующей C-библиотеке, — это сотня потоков. Предел по умолчанию 10 000 потоков (debug.SetMaxThreads), дальше процесс падает с runtime: program exceeds 10000-thread limit

С сетью иначе. Сокеты рантайм переводит в неблокирующий режим и регистрирует в netpoller (epoll в Linux, kqueue в macOS). Горутина, которая ждёт ответа от базы или клиента, паркуется и не держит ни поток, ни P. Когда данные пришли, netpoller возвращает её в очередь. Поэтому тысячи одновременных HTTP-запросов не превращаются в тысячи потоков

Конкурентность и параллелизм

Конкурентность — это как устроена программа: несколько независимых задач, которые продвигаются вперемешку. Параллелизм — это как она выполняется: несколько задач идут в один и тот же момент на разных ядрах. Роб Пайк сформулировал это в докладе «Concurrency is not parallelism»

С GOMAXPROCS=1 программа на горутинах остаётся конкурентной: пока одна горутина ждёт сеть, другая работает. Параллельной она становится только при нескольких P на нескольких ядрах. Хорошо написанный конкурентный код ускоряется от добавления ядер без переписывания

🛠️ На практике

Сколько стоит горутина

Сто тысяч спящих горутин и замер памяти под их стеки:

var before, after runtime.MemStats
runtime.ReadMemStats(&before)

var wg sync.WaitGroup
for i := 0; i < 100_000; i++ {
	wg.Add(1)
	go func() {
		defer wg.Done()
		time.Sleep(time.Second) // горутина спит, поток ОС не занят
	}()
}

runtime.ReadMemStats(&after)
fmt.Println("горутин:", runtime.NumGoroutine())
fmt.Println("стеки, МБ:", (after.StackInuse-before.StackInuse)>>20)
wg.Wait()

Вывод: горутин: 100001 и стеки, МБ: 195, то есть около 2 КБ на горутину. При этом трассировка планировщика показывает всего 10 потоков на весь процесс. Сто тысяч потоков с мегабайтными стеками на обычной машине уже не запустились бы

Трассировку включает переменная GODEBUG=schedtrace=1000: раз в секунду рантайм печатает в stderr строку о своём состоянии. Вот она через секунду после старта той же программы, когда горутины просыпаются:

SCHED 1007ms: gomaxprocs=8 idleprocs=7 threads=10 spinningthreads=1 needspinning=0 idlethreads=7 runqueue=258 [128 0 0 0 0 0 0 0]

runqueue=258 показывает горутины в глобальной очереди, а [128 0 0 …] длины локальных очередей восьми P. Строка помогает понять, хватает ли сервису P и не копится ли очередь. Для подробного разбора задержек есть runtime/trace

GOMAXPROCS в контейнере

До Go 1.25 GOMAXPROCS по умолчанию равнялся числу ядер машины, а лимит CPU контейнера рантайм не видел. Та же проверка в Docker с --cpus=2 на Go 1.23 печатает NumCPU: 4 GOMAXPROCS: 4: четыре P при квоте в два ядра. В Kubernetes под на ноде с 64 ядрами и limits.cpu: 2 получал 64 P

Ядро Linux считает квоту CPU по периодам, обычно по 100 мс. Квота в два ядра — это 200 мс процессорного времени на период. Шестьдесят четыре занятых потока выбирают её за 3 мс, и ядро замораживает контейнер до конца периода. На графиках это хвост задержек в сотни миллисекунд, хотя загрузка CPU выглядит умеренной. Раньше это лечили библиотекой go.uber.org/automaxprocs или переменной GOMAXPROCS в манифесте

С Go 1.25 на Linux рантайм сам читает лимит CPU из cgroup:

Лимит в подеGOMAXPROCS на машине с 8 ядрами
Нет лимита8
limits.cpu: 44
limits.cpu: 2.53, дробный лимит округляется вверх
limits.cpu: 500m2, меньше двух рантайм не ставит

Ещё три правила. requests.cpu не учитывается, только лимит. Раз в секунду рантайм перепроверяет число ядер и лимит, и если их поменяли на лету, меняет GOMAXPROCS. Если GOMAXPROCS задан переменной окружения или вызовом runtime.GOMAXPROCS, всё это отключается. Выключить по отдельности можно через GODEBUG=containermaxprocs=0 и updatemaxprocs=0

⚠️ Где ошибаются

Запускать горутину на каждую единицу работы без лимита. Горутины дешёвые, а то, что они делают, нет. Миллион горутин, каждая из которых открывает соединение с базой или держит буфер на мегабайт, положит сервис раньше планировщика. Число одновременных задач ограничивают пулом воркеров, семафором или errgroup.SetLimit, об этом страница про паттерны конкурентности

Оставлять automaxprocs и ручной GOMAXPROCS после перехода на Go 1.25. Явная настройка выключает автоматическое обновление. Лимит пода подняли с 2 до 4 ядер, а сервис так и работает на двух P. Если причины держать значение вручную нет, библиотеку и переменную из манифеста убирают

Звать блокирующий код из множества горутин. Тяжёлые cgo-вызовы, синхронная работа с медленным диском, сторонние C-библиотеки занимают по потоку на вызов. Под нагрузкой процесс разрастается до тысяч потоков. Такие вызовы пропускают через ограниченный пул горутин

Считать runtime.Gosched() или time.Sleep синхронизацией. «Подождём 10 мс, горутина успеет» работает на ноутбуке и ломается на загруженном проде. Порядок между горутинами задают только каналы, мьютексы, WaitGroup и другие примитивы

Отвечать по устаревшей схеме. «Бесконечный цикл без вызовов функций повесит планировщик» было правдой до Go 1.14. Сейчас сильный ответ упоминает асинхронное вытеснение и называет, когда старое поведение возвращается: с asyncpreemptoff=1

🎯 Вопросы с собеседований

Чем горутина отличается от потока ОС?

Поток создаёт и переключает ядро, у него фиксированный стек, в Linux обычно 8 МБ. Горутину создаёт и переключает рантайм Go в пространстве пользователя, стек у неё стартует с 2 КБ и растёт копированием до 1 ГБ. Поэтому горутин в процессе бывают сотни тысяч, а потоков разумно держать тысячи. Горутины выполняются поверх небольшого числа потоков, распределяет их планировщик Go

Как устроен планировщик Go?

Модель GMP: G означает горутину, M поток ОС, а P логический процессор с локальной очередью готовых горутин. Поток выполняет Go-код, только держа P, а число P равно GOMAXPROCS. Свободный P берёт горутину из своей очереди, иногда из глобальной, из netpoller, а если пусто, крадёт половину очереди у другого P. Долгие горутины вытесняются через 10 мс

Зачем нужен P, если есть G и M?

P хранит то, что нужно для выполнения Go-кода: локальную очередь горутин и кэш памяти для аллокаций. Без него все потоки брали бы горутины из одной общей очереди под одним замком, так и было до Go 1.1. И P можно передать другому потоку, когда текущий застрял в системном вызове: очередь горутин уезжает вместе с ним и не простаивает

Что такое work stealing?

Когда у P закончилась локальная очередь, а в глобальной и в netpoller пусто, его поток выбирает случайный другой P и забирает половину его очереди. Так нагрузка выравнивается без центрального распределителя. Если украсть нечего, поток немного крутится в поиске работы и засыпает

Что происходит, когда горутина делает блокирующий системный вызов?

Поток уходит в ядро вместе с горутиной. Если вызов затянулся, фоновый поток sysmon отбирает у него P и отдаёт другому потоку, при необходимости новому, и остальные горутины продолжают работать. После вызова поток пытается вернуть себе P, а если не вышло, кладёт горутину в глобальную очередь и засыпает. Поэтому потоков бывает больше, чем GOMAXPROCS

А если горутина ждёт ответа по сети?

Сеть в Go работает через netpoller: сокеты неблокирующие и зарегистрированы в epoll или kqueue. Горутина паркуется и не занимает ни поток, ни P. Когда пришли данные, netpoller возвращает её в очередь готовых. Код при этом выглядит синхронным, асинхронность спрятана в рантайме

Может ли горутина с бесконечным циклом заблокировать программу?

С Go 1.14 нет. sysmon замечает горутину, которая работает дольше 10 мс, и вытесняет её сигналом SIGURG, даже если в цикле нет вызовов функций. До 1.14 вытеснение было кооперативным, и такой цикл при GOMAXPROCS=1 вешал программу. Старое поведение возвращает GODEBUG=asyncpreemptoff=1

Чему равен GOMAXPROCS по умолчанию?

Числу логических ядер, а с Go 1.25 на Linux ещё и не больше лимита CPU из cgroup, округлённого вверх, но не меньше двух. В Kubernetes это limits.cpu, запросы не учитываются. Рантайм раз в секунду перепроверяет лимит и подстраивается, если его поменяли. Явная переменная GOMAXPROCS или вызов runtime.GOMAXPROCS эту логику выключают

Чем конкурентность отличается от параллелизма?

Конкурентность — свойство устройства программы: независимые задачи продвигаются вперемешку. Параллелизм — свойство выполнения: задачи идут одновременно на разных ядрах. Программа на горутинах с GOMAXPROCS=1 конкурентная, но не параллельная. Хорошо разложенная на задачи программа становится параллельной сама, когда появляются ядра

Сколько горутин можно запустить?

Жёсткого предела нет, упираются в память: около 2 КБ стека на спящую горутину, сто тысяч занимают порядка 200 МБ. На практике раньше кончаются ресурсы, с которыми горутины работают: соединения с базой, файловые дескрипторы, память под буферы. Поэтому число одновременных задач ограничивают явно

📚 Что почитать

  • Scalable Go Scheduler Design Doc — дизайн-документ Дмитрия Вьюкова, откуда появился P и work stealing
  • Container-aware GOMAXPROCS — статья в блоге Go про новое поведение в контейнерах и троттлинг
  • Concurrency is not parallelism — доклад Роба Пайка, на который ссылаются в ответе про конкурентность
  • runtime/proc.go — исходник планировщика, комментарии в начале файла читаются как документация