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

Go Road Map

📚 Стек, куча и escape analysis

В Go нет ключевого слова, которое решает, где живёт переменная. Это решает компилятор: если значение не переживает функцию, оно ляжет на стек и исчезнет вместе с ней бесплатно. Если переживает или компилятор не может это доказать, значение уезжает в кучу, и потом его убирает сборщик мусора. От этого выбора зависят аллокации, нагрузка на GC и задержки сервиса, поэтому мидла почти всегда спрашивают, что такое escape analysis и как посмотреть его решения

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

Стек горутины

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

Стек горутины стартует с 2 КБ (stackMin = 2048 в runtime/stack.go). С Go 1.19 рантайм на каждом цикле GC считает средний размер стеков и выдаёт новым горутинам стек такого размера, чтобы им реже приходилось расти. Когда места не хватает, рантайм выделяет стек вдвое больше и копирует туда старый, поправив указатели внутри. Во время GC стек, который занят меньше чем на четверть, сжимается вдвое. Подробнее про рост копированием — на странице про горутины и планировщик

Предел — 1 ГБ на 64-битных системах. Бесконечная рекурсия упирается в него и роняет процесс:

runtime: goroutine stack exceeds 1000000000-byte limit
fatal error: stack overflow

Это не паника, recover её не поймает

Куча

Куча — общая память процесса для значений, время жизни которых на этапе компиляции неизвестно. Аллокация в куче — вызов runtime.mallocgc: найти свободный блок нужного размера, иногда помочь сборщику с разметкой. Освобождает такие значения только GC, и чем больше программа аллоцирует, тем чаще он запускается. Поэтому в нагруженном сервисе число аллокаций на запрос — одна из главных метрик производительности

СтекКуча
Кто освобождаетвозврат из функциисборщик мусора
Цена аллокациипочти ноль, место в кадре известно заранеевызов аллокатора и будущая работа GC
Чья памятьодной горутиныобщая для всех горутин
Размерфиксирован на этапе компиляциилюбой, в том числе известный только в рантайме

Escape analysis

При компиляции Go строит граф: какое значение куда передаётся, чей адрес куда записан. Если указатель на переменную может оказаться доступен после возврата функции, переменная убегает (escapes) в кучу. Основные причины:

  • функция возвращает указатель на локальную переменную
  • адрес записали в глобальную переменную, в поле структуры из кучи, в канал или в мапу
  • переменную захватило замыкание, которое живёт дольше функции, например горутина
  • значение положили в интерфейс, а дальше компилятор его не видит. Так происходит с аргументами fmt.Println
  • размер известен только в рантайме, например make([]T, n) с переменной n
  • значение слишком большое: явная переменная больше 128 КБ или неявная (new(T), &T{}, make) больше 64 КБ

Правило транзитивное. Если указатель записали в значение, которое уже убежало, убегает и то, на что он указывает

Посмотреть решения компилятора можно флагом -gcflags=-m. Вот небольшой файл и вывод Go 1.27.3:

func byValue() User { // копия уходит вызывающему
	u := User{ID: 1, Name: "a"}
	return u
}

func byPointer() *User { // адрес переживает функцию
	u := User{ID: 1, Name: "a"}
	return &u
}

func local() int { // указатель не выходит из функции
	u := &User{ID: 1}
	return u.ID
}

func logID(id int) { fmt.Println(id) }

func counter() func() int {
	n := 0
	return func() int { n++; return n }
}
./esc.go:16:2: moved to heap: u
./esc.go:21:7: &User{...} does not escape
./esc.go:26:14: id escapes to heap
./esc.go:30:2: moved to heap: n
./esc.go:31:9: func literal escapes to heap

byValue в выводе нет: копия возвращается через стек вызывающего. &User{...} в local остался на стеке, хотя это указатель. Знак & ничего не решает, решает то, куда указатель уходит. Если добавить -m=2, компилятор распишет цепочку, по которой значение убежало: flow: ~r0 ← &u, from return &u (return). Те же решения видно в редакторе: в VS Code с gopls команда «Go: Toggle compiler optimization details» подсвечивает их прямо в коде

Что поменялось в последних версиях

Раньше любой make с размером из переменной уходил в кучу: кадр стека в Go фиксированного размера, alloca нет. В Go 1.25 компилятор начал резервировать в кадре буфер на 32 байта и класть туда срез, если запрошенный размер в него влезает. В Go 1.26 то же сделали для append: первые элементы среза, который начинался с nil, ложатся в такой же буфер на стеке (для int это 4 элемента), а если срез возвращают из функции, компилятор в конце один раз копирует его в кучу нужного размера. Подробно об этом рассказал Кит Рэндалл в блоге Go в феврале 2026

Проверка тем же кодом на Go 1.23 и 1.27.3, число аллокаций на вызов:

КодGo 1.23Go 1.27
make([]int, n) при n = 310
make([]int, n) при n = 10011
4 append в локальный nil-срез30
9 append в локальный nil-срез52
1000 append без cap, срез возвращается129

Вывод -m тоже изменился: на 1.23 про make([]int, 0, n) было escapes to heap, на 1.27 — does not escape. Если после обновления сломалось что-то, связанное с unsafe.Pointer, новые аллокации на стеке выключает -gcflags=all=-d=variablemakehash=n

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

Указатель не всегда быстрее

Частый совет «возвращай указатель, чтобы не копировать» на маленьких и средних структурах работает наоборот. Бенчмарк с go test -bench . -benchmem на структуре в 256 байт, Go 1.27.3, Apple M1 Pro:

BenchmarkValue-8            5.1 ns/op     0 B/op   0 allocs/op
BenchmarkPointer-8         85.2 ns/op   256 B/op   1 allocs/op
BenchmarkPointerInlined-8   2.2 ns/op     0 B/op   0 allocs/op

Копия 256 байт по значению стоит 5 нс. Та же структура по указателю из функции, которую запретили встраивать (//go:noinline), уезжает в кучу и стоит в 16 раз дороже, плюс работа GC потом. Третья строка — маленькая функция с return &u: компилятор её встроил, указатель перестал выходить за пределы цикла, и аллокация пропала

Практическое правило: выбирай указатель или значение по смыслу. Указатель — когда метод меняет структуру, когда значение большое (килобайты) или когда его нельзя копировать, как структуры с sync.Mutex. В остальных случаях значение работает так же или быстрее

Преаллокация

append без запаса растит срез с переносом данных: ёмкость удваивается, пока срез маленький, потом растёт медленнее. На 1000 элементов это 9–12 аллокаций и 25 КБ мусора. Если размер известен или его можно оценить, задай ёмкость сразу:

out := make([]int, 0, len(ids)) // одна аллокация вместо девяти
for _, id := range ids {
	out = append(out, id)
}

В бенчмарке на 1000 элементов это 1 аллокация на 8 КБ вместо 9 на 25 КБ и вдвое меньше времени. То же с мапами: make(map[string]int, n). Как устроен рост среза, разобрано на странице про массивы и слайсы

sync.Pool

Когда объект нужен ненадолго, но в каждом запросе (буфер для ответа, временная структура для разбора), его можно не аллоцировать заново, а брать из пула:

Go · Буфер из sync.Pool

var bufPool = sync.Pool{
	New: func() any { return new(bytes.Buffer) },
}

func render(w io.Writer, items []string) error {
	buf := bufPool.Get().(*bytes.Buffer)
	buf.Reset() // в пуле лежит буфер с прошлыми данными
	defer bufPool.Put(buf)

	for _, it := range items {
		buf.WriteString(it)
	}
	_, err := w.Write(buf.Bytes())
	return err
}

В бенчмарке функция с новым буфером на 4 КБ делала 1 аллокацию и работала 808 нс, с пулом — 0 аллокаций и 357 нс. Так устроен буфер внутри fmt: под нагрузкой пул растёт, в простое сжимается

Четыре свойства пула, о которых спрашивают:

  1. Пул не хранилище. Объекты, которые не взяли за два цикла GC, сборщик выбрасывает: на первом цикле они переезжают во вспомогательный кэш victim, на втором удаляются
  2. Get может вернуть любой ранее положенный объект или новый из New. Состояние перед использованием сбрасывают
  3. Огромные буферы в пул обратно не кладут. Один ответ на 50 МБ иначе навсегда раздует все буферы пула. В fmt стоит проверка ёмкости перед Put
  4. Пул копировать нельзя после первого использования, go vet это ловит

Как найти горячую аллокацию

-gcflags=-m показывает все решения сразу, и вывод на реальном проекте огромный. Начинают с профиля: в CPU-профиле заметная доля runtime.mallocgc (по GC guide больше 15%) говорит, что программа много аллоцирует. Дальше heap-профиль в режиме alloc_space показывает, какие строки кода аллоцируют больше всего байт. Уже для этих строк смотрят -m=2 и решают, что поменять. Профилирование разобрано отдельной страницей модуля

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

  • Оптимизируют по выводу -m без профиля. Строчка escapes to heap в коде, который вызывается раз в минуту, ничего не стоит. Переписывать стоит только то, что видно в alloc_space
  • Ставят указатели везде «для скорости». Каждый указатель на короткоживущую структуру рискует стать аллокацией, а GC сканирует только память с указателями. Слайс структур без указателей сборщик почти не замечает, слайс указателей он обходит целиком
  • Возвращают из пула объект и продолжают им пользоваться. После Put буфер может достаться другой горутине. Если buf.Bytes() отдали наружу и потом вызвали Put, данные перезапишет чужой запрос
  • Считают, что new всегда даёт кучу. new(T) и &T{} подчиняются тому же escape analysis: не убежали — лежат на стеке
  • Ждут, что большой локальный массив будет бесплатным. var buf [1 << 20]byte больше 128 КБ и уедет в кучу. Массив поменьше останется на стеке, но кадр на 100 КБ заставит стек горутины несколько раз вырасти, и каждый рост копирует стек целиком

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

Чем стек отличается от кучи в Go?

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

Что такое escape analysis и как посмотреть его результат?

Это анализ при компиляции: компилятор следит, куда уходят указатели на значения. Если указатель может пережить функцию (её вернули, записали в глобальную переменную, захватили в горутину, положили в интерфейс), значение убегает в кучу. Посмотреть решения можно через go build -gcflags=-m, а -m=2 показывает, по какой цепочке значение убежало. Анализ работает после встраивания, поэтому результат зависит от места вызова

Когда переменная попадает в кучу?

Когда её адрес переживает функцию: возврат указателя, запись в глобальную переменную, канал, мапу или поле объекта из кучи, захват замыканием, которое живёт дольше функции. Ещё когда компилятор теряет её из виду при упаковке в интерфейс, когда размер известен только в рантайме и он больше небольшого буфера на стеке, и когда значение большое: больше 64 КБ для make и new, больше 128 КБ для явной переменной

Что быстрее: вернуть структуру по значению или по указателю?

Для маленьких и средних структур обычно по значению: копия из пары сотен байт стоит единицы наносекунд, а указатель часто означает аллокацию в куче и работу для GC. В моём бенчмарке на 256 байтах разница была в 16 раз в пользу значения. Указатель выбирают по смыслу: когда нужно менять оригинал, когда структура большая или её нельзя копировать. Если функция встроилась, указатель может и не дать аллокации

Как растёт стек горутины и есть ли у него предел?

Стартует с 2 КБ, а с Go 1.19 со среднего размера стеков, который рантайм считает на каждом GC. Когда функции не хватает места, рантайм выделяет стек вдвое больше, копирует старый и поправляет указатели на него. Во время GC редко используемый стек сжимается. Предел на 64-битных системах 1 ГБ, при его превышении процесс падает с fatal error: stack overflow, это не перехватывается через recover

Зачем нужен sync.Pool и какие у него подводные камни?

Чтобы переиспользовать временные объекты и не аллоцировать их в каждом запросе, например буферы. Пул не гарантирует, что объект сохранится: за два цикла GC невостребованные объекты удаляются. Объект из пула нужно сбросить перед использованием, нельзя трогать после Put и не стоит возвращать слишком большие буферы. Для долгоживущего кэша пул не подходит

Почему fmt.Println(x) приводит к аллокации?

Аргументы Println имеют тип any, и компилятор не может доказать, что fmt не сохранит значение где-то дальше. Поэтому значение, упакованное в интерфейс, убегает в кучу, в выводе -m это x escapes to heap. Для маленьких целых рантайм использует заранее готовые значения, так что аллокации может и не быть, но в горячем пути логирование через fmt всё равно заметно в профиле

Что поменялось в размещении срезов в последних версиях Go?

Раньше make([]T, n) с переменной n всегда шёл в кучу, потому что кадр стека имеет фиксированный размер. С Go 1.25 компилятор резервирует в кадре буфер на 32 байта и использует его, если срез влезает. С Go 1.26 так же работают первые append в пустой срез, а возвращаемый срез копируется в кучу один раз в конце. Ручная оптимизация с веткой «маленький размер — константа» стала не нужна

Как найти, откуда в сервисе лишние аллокации?

Начинают с профиля, -gcflags=-m на целом проекте выдаст тысячи строк. Сначала CPU-профиль: если много времени в runtime.mallocgc, программа аллоцирует слишком много. Потом heap-профиль с -sample_index=alloc_space покажет строки, которые выделяют больше всего байт. Для них уже смотрят -m=2, пишут бенчмарк с -benchmem и проверяют, что allocs/op после правки упал

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

  • Allocating on the Stack — пост Кита Рэндалла о том, как в Go 1.25 и 1.26 срезы переехали на стек, с примерами кода
  • A Guide to the Go Garbage Collector — разделы «Where Go Values Live» и «Eliminating heap allocations»: откуда берутся аллокации и как их искать в профиле
  • Go FAQ: стек или куча — короткий официальный ответ, почему программисту не нужно знать, где лежит переменная, и когда всё-таки нужно
  • Документация sync.Pool — когда пул уместен, а когда нет, с примером из fmt