♻️ Сборщик мусора и Green Tea
Всё, что убежало в кучу, кто-то должен убрать. В Go это делает сборщик мусора: он работает параллельно с программой, сам решает, когда запуститься, и почти не останавливает горутины. Вопрос «как работает GC в Go» задают мидлу чаще любого другого вопроса про язык. Хороший ответ укладывается в три вещи: трёхцветная разметка, write barrier и то, как GOGC и GOMEMLIMIT решают, когда начинать цикл. Сверху сейчас добавляют четвёртую: что поменял Green Tea, который стал сборщиком по умолчанию в Go 1.26
🧠 Как это устроено
Что за сборщик
Сборщик в Go трассирующий: он не считает ссылки, а обходит граф объектов от корней и всё, до чего не дошёл, считает мусором. Корни — это глобальные переменные и указатели на стеках горутин. Ещё три свойства, о которых спрашивают отдельно:
- конкурентный с Go 1.5: почти вся работа идёт одновременно с кодом программы
- без поколений: нет деления на молодые и старые объекты, как в JVM, каждый цикл размечает всю живую кучу
- без перемещения: объекты не двигаются и не уплотняются, адрес значения не меняется за всю его жизнь
Без поколений и без перемещения сборщик проще, и ему не нужно чинить указатели после переезда объекта. Зато цена цикла растёт вместе с размером живой кучи, а фрагментацию держит аллокатор: он раскладывает объекты по классам размеров, и объекты одного класса лежат рядом на своих страницах. Какие значения вообще попадают в кучу, разобрано на странице про стек, кучу и escape analysis
Трёхцветная разметка
Каждый объект во время разметки находится в одном из трёх состояний:
- белый — сборщик его ещё не видел. Белые объекты, оставшиеся к концу разметки, недостижимы и будут освобождены
- серый — достижим, но его поля ещё не просмотрены. Серые объекты лежат в очереди работы
- чёрный — достижим, и все указатели из него уже просмотрены
Разметка начинается с корней: всё, на что они указывают, становится серым. Дальше сборщик берёт серый объект, красит в серый всё, на что тот ссылается, а сам объект перекрашивает в чёрный. Когда серых не осталось, разметка закончена. Объекты, созданные во время разметки, сразу считаются чёрными: они точно живые, проверять их незачем
Главный инвариант: чёрный объект не должен указывать на белый. Если программа во время разметки запишет указатель на белый объект в уже чёрный и сотрёт все остальные пути к нему, сборщик до него не дойдёт и освободит живую память. Отсюда следующий механизм
Write barrier
Пока идёт разметка, компилятор оборачивает каждую запись указателя в куче в write barrier: небольшой кусок кода, который сообщает сборщику о записи. В Go он гибридный, так написано в runtime/mbarrier.go. При записи *slot = ptr барьер красит старое значение *slot (часть Юасы), а если стек текущей горутины ещё не просканирован, красит и новое ptr (часть Дейкстры). Так программа не спрячет объект от сборщика, ни перенеся единственный указатель из кучи на стек, ни наоборот
Гибридный барьер появился в Go 1.8. До него сборщику приходилось в конце разметки останавливать мир и сканировать стеки заново, и паузы были длиннее. В release notes 1.8 обещали паузы обычно меньше 100 микросекунд. Барьер включён только во время разметки, в остальное время запись указателя стоит обычную запись
Цикл целиком
По комментарию в runtime/mgc.go цикл состоит из четырёх шагов, и мир останавливается два раза, оба коротко:
- Stop the world: все P доходят до безопасной точки, включается write barrier
- Разметка конкурентно: сканируются стеки (каждую горутину останавливают ненадолго, только на время сканирования её стека), глобальные переменные, потом очередь серых объектов. Фоновые воркеры GC занимают 25% CPU, это константа
gcBackgroundUtilization = 0.25вmgcpacer.go - Stop the world: завершение разметки, барьер выключается
- Очистка конкурентно: белые объекты освобождаются по страницам, лениво при аллокации и в фоновой горутине
Есть ещё mark assist. Если горутина аллоцирует быстрее, чем сборщик успевает размечать, рантайм заставляет её саму поработать на разметку, прежде чем выдать память. Это защищает от того, что куча вырастет раньше, чем закончится цикл, но для программы выглядит как внезапно медленная аллокация. В GC guide это одна из пяти причин задержек, вместе с паузами, 25% CPU, барьером и остановкой горутины на время сканирования её стека
Когда запускается цикл: GOGC
Цикл запускается, когда куча дорастает до цели. Формула из GC guide:
цель кучи = живая куча + (живая куча + корни) × GOGC / 100По умолчанию GOGC=100: если после разметки живых данных 100 МБ, следующий цикл начнётся около 200 МБ. Удвоишь GOGC — памяти уйдёт примерно вдвое больше, а CPU на сборку примерно вдвое меньше. GOGC=off выключает сборщик, если не задан лимит памяти. Меньше 4 МБ цель не бывает. Ещё рантайм принудительно запускает цикл, если сборки не было 2 минуты (forcegcperiod в proc.go)
Лимит памяти: GOMEMLIMIT
С Go 1.19 есть второй регулятор, GOMEMLIMIT. Это мягкий лимит на всю память, которой управляет рантайм: куча, стеки, служебные структуры. Память C-библиотек через cgo и сам бинарник в него не входят. Задаётся в байтах с суффиксами KiB, MiB, GiB, например GOMEMLIMIT=900MiB, или из кода через debug.SetMemoryLimit. По умолчанию лимита нет
Когда память подходит к лимиту, сборщик запускается чаще, чем требует GOGC. Чтобы программа не ушла в бесконечную сборку, рантайм ограничивает GC примерно 50% CPU в окне 2 × GOMAXPROCS CPU-секунд. Поэтому неудачный лимит замедлит программу максимум примерно вдвое, но не остановит её. Лимит мягкий: если живых данных больше лимита, рантайм его превысит, а OOM-killer придёт как обычно
Green Tea
Старый сборщик клал в очередь отдельные объекты и обходил граф примерно в глубину. Объекты соседних уровней графа лежат в разных местах памяти, поэтому процессор постоянно ждёт память. По данным авторов, разметка — около 90% стоимости GC, и минимум 35% её времени уходит на такие ожидания
Green Tea меняет единицу работы. В очередь попадает не объект, а страница кучи размером 8 КБ с маленькими объектами. Для каждого объекта на странице хранятся два бита: «видели» и «просканировали». Пока страница ждёт в очереди, на ней копятся новые помеченные объекты, и когда до неё доходит очередь, сборщик сканирует их пачкой, подряд по памяти. Очередь страниц работает как FIFO, а не как стек, и одна страница может попасть в неё за цикл несколько раз
| Классическая разметка | Green Tea | |
|---|---|---|
| Единица работы | объект | страница 8 КБ с маленькими объектами |
| Порядок обхода | стек, примерно в глубину | FIFO-очередь страниц |
| Доступ к памяти | прыжки по куче | подряд внутри страницы |
| Векторные инструкции | нет | AVX-512 на Intel Ice Lake и AMD Zen 4 и новее |
В release notes 1.26 обещают на 10–40% меньше накладных расходов GC в программах, которые активно нагружают сборщик, и ещё около 10% на новых x86 за счёт векторных инструкций. Худший случай — когда на странице за раз находится один объект для сканирования: тогда Green Tea может быть медленнее старого обхода, и полностью этот случай не закрыт. Выключить новый сборщик можно при сборке: GOEXPERIMENT=nogreenteagc. В 1.26 обещали убрать эту опцию в 1.27, но в Go 1.27.3 она ещё работает
🛠️ На практике
Программа держит около 120 МБ живых маленьких объектов и создаёт ещё 2 ГБ мусора. В конце она печатает число циклов, цель кучи, всю память рантайма и долю CPU, ушедшую на GC:
Go · Программа для экспериментов с GOGC и GOMEMLIMIT
package main
import (
"fmt"
"runtime"
"runtime/metrics"
"time"
)
type node struct {
next *node
val [6]int64
}
var live []*node // живая куча, которую GC обязан обходить
func main() {
for i := 0; i < 1_600_000; i++ {
live = append(live, &node{})
}
start := time.Now()
var sink *node
// мусор: 30 млн коротко живущих объектов по 64 байта
for i := 0; i < 30_000_000; i++ {
sink = &node{next: sink}
if i%64 == 0 {
sink = nil
}
}
_ = sink
s := []metrics.Sample{
{Name: "/gc/cycles/total:gc-cycles"},
{Name: "/gc/heap/goal:bytes"},
{Name: "/memory/classes/total:bytes"},
}
metrics.Read(s)
var ms runtime.MemStats
runtime.ReadMemStats(&ms)
fmt.Printf("циклов GC: %d, цель кучи: %d МБ, память рантайма: %d МБ, время: %v, GC CPU: %.1f%%\n",
s[0].Value.Uint64(), s[1].Value.Uint64()>>20, s[2].Value.Uint64()>>20,
time.Since(start).Round(10*time.Millisecond), ms.GCCPUFraction*100)
runtime.KeepAlive(live)
}Результаты на Go 1.27.3, Apple M1 Pro, 8 ядер:
| Запуск | Циклов | Цель кучи | Память рантайма | Время | GC CPU |
|---|---|---|---|---|---|
GOGC=50 | 51 | 181 МБ | 198 МБ | 580 мс | 7,9% |
GOGC=100 | 27 | 241 МБ | 244 МБ | 480 мс | 5,0% |
GOGC=400 | 6 | 616 МБ | 626 МБ | 450 мс | 1,6% |
GOGC=off | 0 | — | 2121 МБ | 580 мс | 0% |
GOMEMLIMIT=150MiB | 122 | 132 МБ | 152 МБ | 1020 мс | 14,2% |
Здесь видна вся механика. GOGC меняет память на CPU: GOGC=400 вместо 100 дал в четыре с половиной раза меньше циклов и в два с половиной раза больше памяти. Без сборщика процесс съел 2 ГБ и при этом быстрее не стал: 580 мс против 480. А лимит 150 МБ при 120 МБ живых данных удержал память, но сборщик запускался 122 раза и программа работала вдвое дольше. Это и есть та самая граница «максимум примерно вдвое»: лимит слишком близко к живой куче
Тот же бинарник, собранный с GOEXPERIMENT=nogreenteagc, в трёх прогонах тратил на GC 8,3–8,7% CPU против 5,2–5,5% у Green Tea, то есть примерно на треть меньше. Общее время при этом не изменилось, 430–500 мс у обоих: программа упирается в аллокации, а не в разметку. На M1 нет AVX-512, так что векторной части в этом сравнении нет
Как посмотреть на GC в своём сервисе
GODEBUG=gctrace=1 печатает в stderr строку на каждый цикл:
gc 9 @0.071s 6%: 0.015+4.8+0.011 ms clock, 0.12+0.053/8.9/21+0.090 ms cpu, 206->216->120 MB, 239 MB goal, 0 MB stacks, 0 MB globals, 8 PЧто в ней читать:
6%— доля времени в GC с начала программы0.015+4.8+0.011 ms clock— первая пауза, конкурентная разметка, вторая пауза. Паузы здесь 15 и 11 микросекунд, разметка почти 5 мс идёт параллельно с программой0.053/8.9/21в CPU — время mark assist, фоновых воркеров и разметки в простое. Если первое число растёт, горутины сами платят за сборку206->216->120 MB— куча в начале цикла, в конце и живая. 120 МБ живых данных иGOGC=100дают цель 239 МБ, как по формуле8 P— сколько процессоров видит рантайм
В проде то же самое берут из runtime/metrics: /gc/heap/goal:bytes, /gc/heap/live:bytes, /gc/cycles/total:gc-cycles, /cpu/classes/gc/total:cpu-seconds. Где именно аллоцирует код, покажет heap-профиль, о нём на странице про профилирование
Лимит в контейнере
Типичная настройка для сервиса в Kubernetes с лимитом памяти 1 ГБ:
env:
- name: GOMEMLIMIT
value: "900MiB" # лимит контейнера минус 5–10% на память вне рантаймаGOGC оставляют по умолчанию. Пока памяти хватает, сборщик работает по GOGC, а у лимита начинает запускаться чаще и не даёт процессу дорасти до OOM-killer на пиках. Подробнее про контейнеры, cgroup и GOMAXPROCS — на следующей странице модуля
⚠️ Где ошибаются
GOMEMLIMIT вплотную к живой куче. Если сервис стабильно держит 800 МБ живых данных, лимит 850 МБ превратит его в машину для сборки мусора: GC съест до половины CPU, задержки вырастут. Лимит спасает от пиков, а постоянную нехватку памяти лечат увеличением памяти или уменьшением живой кучи
GOGC=off вместе с лимитом на машине с соседями. GC guide прямо советует так не делать, если программа делит память с другими процессами. Сборщик будет ждать лимита, и память процесса всегда будет у потолка. Безопаснее лимит и разумный GOGC
Ручной runtime.GC() «для порядка». Вызов запускает полный цикл вне расписания и блокирует вызывающую горутину, пока сборка не закончится, а по документации может остановить и всю программу. В сервисе он почти никогда не нужен, а если хочется вернуть память ОС, для этого есть debug.FreeOSMemory, и он тоже нужен редко
Финализаторы вместо Close. runtime.SetFinalizer воскрешает объект, объект в цикле ссылок с финализатором не освободится никогда, и неизвестно, когда финализатор отработает. С Go 1.24 GC guide советует runtime.AddCleanup, но и его держат как страховку. Файлы и соединения закрывают явно
Смотреть на RSS и пугаться. Освобождённая память не сразу возвращается ОС, рантайм отдаёт её постепенно. Кроме того, на 64-битных системах у процесса Go около 700 МБ виртуальной памяти с самого старта. Смотреть надо на RSS и метрики рантайма, а не на VSZ
🎯 Вопросы с собеседований
Как работает сборщик мусора в Go?
Это конкурентный трассирующий mark-and-sweep без поколений и без перемещения объектов. Цикл начинается с короткой остановки мира, где включается write barrier. Потом сборщик параллельно с программой размечает живые объекты трёхцветным алгоритмом от корней: стеков и глобальных переменных. Вторая короткая пауза завершает разметку, а очистка неразмеченного идёт уже в фоне и при аллокациях. Паузы обычно меньше миллисекунды, цена — около 25% CPU на время разметки и write barrier на записях указателей
Что такое трёхцветная разметка?
Объекты делятся на белые (не видели), серые (видели, но не просмотрели их поля) и чёрные (просмотрели целиком). Сначала серыми становятся объекты, на которые указывают корни. Сборщик берёт серый объект, красит в серый всё, на что он ссылается, а сам становится чёрным. Когда серых не осталось, белые объекты недостижимы и освобождаются. Инвариант: чёрный объект не указывает на белый, иначе сборщик пропустит живой объект
Зачем нужен write barrier?
Программа работает во время разметки и может переложить указатель на белый объект в уже чёрный, стерев другие пути к нему. Без барьера сборщик освободил бы живую память. Барьер при записи указателя красит старое значение, а пока стек горутины не просканирован, ещё и новое. Это гибридный барьер Юасы и Дейкстры, он появился в Go 1.8 и убрал повторное сканирование стеков на паузе. Работает он только во время разметки
Когда запускается GC и что делает GOGC?
Цикл стартует, когда куча дорастает до цели: живая куча плюс (живая куча + корни) × GOGC / 100. При GOGC=100 и 100 МБ живых данных следующий цикл будет около 200 МБ. Увеличение GOGC тратит больше памяти и меньше CPU, уменьшение наоборот, GOGC=off выключает сборку. Ещё цикл запускается принудительно, если его не было 2 минуты, и по runtime.GC()
Что такое GOMEMLIMIT и чем он отличается от GOGC?
GOGC задаёт память относительно живой кучи, GOMEMLIMIT — абсолютный мягкий потолок всей памяти рантайма, он появился в Go 1.19. У потолка сборщик запускается чаще, чем требует GOGC. Чтобы не уйти в бесконечную сборку, GC ограничен примерно 50% CPU, поэтому плохой лимит замедлит программу, но не остановит. В контейнере лимит ставят на 5–10% ниже лимита памяти контейнера
Что изменил Green Tea?
Сборщик стал обрабатывать не отдельные объекты, а страницы кучи по 8 КБ с маленькими объектами. Пока страница стоит в очереди, на ней копятся помеченные объекты, и их сканируют пачкой, подряд по памяти, а не прыжками по графу. Разметка меньше ждёт память, и на новых x86 для неё работают векторные инструкции. Обещают на 10–40% меньше накладных расходов GC. Включён по умолчанию с Go 1.26, алгоритм трёхцветной разметки и барьер те же
Почему в Go нет поколений, как в Java?
Команда Go пробовала сборщик с поколениями, без перемещения объектов, и отказалась. Поколениям нужен write barrier на каждой записи указателя всегда, а не только во время разметки, и на бенчмарках этот налог не окупился. Вторая причина в escape analysis: многие короткоживущие значения в Go живут и умирают на стеке, так что молодых объектов в куче меньше, чем в Java. Это подробно разобрано в докладе Рика Хадсона из блога Go
Сервис тормозит из-за GC. Что будешь делать?
Сначала подтвердить: gctrace=1 или метрики покажут частоту циклов, долю CPU и рост mark assist. Дальше heap-профиль с alloc_space покажет, кто больше всех аллоцирует. Лечится это в первую очередь уменьшением аллокаций: преаллокация срезов, переиспользование буферов, sync.Pool, значения вместо указателей. Если память есть, можно поднять GOGC и поставить GOMEMLIMIT, чтобы сборка шла реже, но не упёрлась в OOM
Почему процесс Go занимает больше памяти, чем живая куча?
Куча растёт до цели, а не до живых данных: при GOGC=100 это примерно вдвое больше живого. Освобождённые страницы рантайм возвращает ОС постепенно, фоновым процессом. Ещё есть стеки горутин, служебные структуры рантайма и память cgo, которую сборщик не видит. Поэтому GOMEMLIMIT ставят с запасом, а не ровно по лимиту контейнера
📚 Что почитать
- A Guide to the Go Garbage Collector — официальное руководство: модель стоимости,
GOGC,GOMEMLIMIT, интерактивные графики и разбор причин задержек - The Green Tea Garbage Collector — статья авторов Green Tea в блоге Go: почему обход по объектам упирается в память и как работают страницы
- Getting to Go: The Journey of Go's Garbage Collector — доклад Рика Хадсона о том, как сборщик пришёл к низким паузам и почему без поколений
- Eliminate STW stack re-scanning — дизайн-документ гибридного write barrier с доказательством корректности