Когда переменная в Go уходит в кучу и как это проверить через escape analysis?
Проверила команда Сопровод · Обновлено
Короткий ответ
Где жить переменной, решает компилятор, синтаксис new и & этого не определяет. Escape analysis оставляет значение на стеке, если доказал, что оно не переживет функцию. В кучу оно уходит, когда указатель сохраняют за пределами вызова: в глобальную переменную, канал, замыкание горутины или интерфейс, который переживет функцию. Решения показывает go build -gcflags=-m, цену — счетчик аллокаций.
Почему этот вопрос задают
Лишние аллокации в горячем коде нагружают сборщик мусора и поднимают задержки. Middle-разработчик должен понимать, почему одна строка выделяет память, а соседняя нет, и уметь это проверить.
Как рассуждать
- Начните с того, кто решает: место хранения выбирает компилятор при сборке программы
- Назовите главные причины побега: указатель или интерфейс переживает функцию, замыкание горутины, большой размер
- Покажите проверку:
go build -gcflags=-mпечатаетescapes to heapилиdoes not escape - Подтвердите цену числом аллокаций:
-benchmemв бенчмарке илиtesting.AllocsPerRun
Ответ с примером
Значение уходит в кучу, когда ссылка на него переживает вызов, и это видно по счетчику аллокаций. Пример считает поездку в такси: 99 ₽ за посадку и 32 ₽ за километр. testing.AllocsPerRun возвращает число аллокаций на один вызов. pricePtr отдает указатель, но компилятор встроил ее в место вызова, увидел, что результат не покидает замыкание, и оставил структуру на стеке: 0 аллокаций. Когда тот же указатель сохранили в глобальную sink, структура пережила вызов и ушла в кучу: 1 аллокация. price отдает структуру по значению, но присваивание в ту же sink типа any скопировало ее в кучу: еще 1.
go build -gcflags=-m подтверждает это строками &Fare{...} does not escape у первого замыкания и &Fare{...} escapes to heap у второго.
type Fare struct{ Km, Rub int }
var sink any
func price(km int) Fare { return Fare{km, 99 + km*32} }
func pricePtr(km int) *Fare { return &Fare{km, 99 + km*32} }
func main() {
ptr := testing.AllocsPerRun(100, func() { _ = pricePtr(12).Rub })
kept := testing.AllocsPerRun(100, func() { sink = pricePtr(12) })
boxed := testing.AllocsPerRun(100, func() { sink = price(12) })
fmt.Println(ptr, kept, boxed)
}0 1 1
Как ответить сильнее
Что добавит опытный кандидат
Что спросят следом
Доступно по подписке
Приемы опытных и готовые ответы
Частые ошибки
«
newи&всегда выделяют память в куче»Поправьте: место выбирает компилятор. Указатель, который не покидает функцию, остается на стеке, даже если создан через
new«Локальная переменная в Go живет на стеке, как в C»
Объясните, что в Go можно вернуть адрес локальной переменной: компилятор сам перенесет ее в кучу, и висячего указателя не будет
«Escape analysis работает во время выполнения программы»
Уточните, что анализ делает компилятор при сборке. Во время работы программы решения не меняются, и их видно заранее через
-gcflags=-m«Раз структура ушла в кучу, код надо срочно переписать»
Скажите, что аллокация важна в горячем коде. Сначала найдите ее в профиле
pprofили в бенчмарке, потом решайте, стоит ли переписывать
Сигналы для интервьюера
Сильный ответ
Предсказывает по коду, какая строка выделит память, проверяет прогноз через -gcflags=-m и показывает разницу в бенчмарке
Тревожный сигнал
Говорит про стек и кучу общими словами, но не может прочитать вывод -gcflags=-m и найти в нем свою переменную
Красный флаг
Уверен, что память в куче освобождается сразу при выходе из функции, и не связывает аллокации с работой сборщика мусора
Как еще могут спросить
- Что такое escape analysis в Go?
- Как понять, где выделяется память: на стеке или в куче?
- Почему в Go можно вернуть указатель на локальную переменную?
- Что показывает флаг
-gcflags=-m?











