📚 Стек, куча и 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 heapbyValue в выводе нет: копия возвращается через стек вызывающего. &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.23 | Go 1.27 |
|---|---|---|
make([]int, n) при n = 3 | 1 | 0 |
make([]int, n) при n = 100 | 1 | 1 |
4 append в локальный nil-срез | 3 | 0 |
9 append в локальный nil-срез | 5 | 2 |
1000 append без cap, срез возвращается | 12 | 9 |
Вывод -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: под нагрузкой пул растёт, в простое сжимается
Четыре свойства пула, о которых спрашивают:
- Пул не хранилище. Объекты, которые не взяли за два цикла GC, сборщик выбрасывает: на первом цикле они переезжают во вспомогательный кэш
victim, на втором удаляются Getможет вернуть любой ранее положенный объект или новый изNew. Состояние перед использованием сбрасывают- Огромные буферы в пул обратно не кладут. Один ответ на 50 МБ иначе навсегда раздует все буферы пула. В
fmtстоит проверка ёмкости передPut - Пул копировать нельзя после первого использования,
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