Какие данные попадают в стек?

Стек и его содержимое в Go

В Go (Golang) стек используется для хранения данных, связанных с вызовами функций и локальными переменными. Это область памяти с быстрым доступом (LIFO — Last In, First Out), управляемая непосредственно компилятором Go и рантаймом. В отличие от C/C++, в Go стек более абстрагирован, но его содержимое можно обобщить.

Основные типы данных, хранящихся в стеке

1. Локальные переменные функций

Локальные переменные, объявленные внутри функции, если они не удовлетворяют условиям для escape-анализа (побега в кучу). Компилятор Go проводит escape-анализ на этапе компиляции, чтобы решить, где разместить переменную: в стеке (если её время жизни ограничено функцией) или в куче (если она может пережить вызов функции).

func example() {
    // Эти переменные, скорее всего, разместятся в стеке
    x := 42           // int
    s := "local"      // string (заголовок строки может быть в стеке)
    arr := [3]int{1, 2, 3} // массив фиксированного размера
    
    // Слайс: заголовок (slice header) может быть в стеке, 
    // но данные, на которые он указывает, — в куче.
    slice := make([]int, 0, 10)
}

2. Аргументы функций (параметры)

Значения, передаваемые в функцию, помещаются в стек (если это не большие структуры или интерфейсы, которые могут обрабатываться иначе).

func add(a int, b int) int {
    // a и b размещаются в стеке при вызове add
    return a + b
}

3. Возвращаемые значения

Как и аргументы, возвращаемые значения функции также могут храниться в стеке (если они не требуют выделения в куче из-за размера или escape-анализа).

4. Указатели и ссылки на данные в стеке

Само значение указателя (адрес) может храниться в стеке, но данные, на которые он указывает, могут быть как в стеке, так и в куче.

5. Структуры и массивы фиксированного размера

Небольшие структуры и массивы, которые не «убегают» (escape) из функции, компилятор размещает в стеке.

6. Информация о вызове функции (кадр стека — stack frame)

Каждый вызов функции создаёт кадр стека, который содержит:

• Адрес возврата (return address) — куда вернуться после завершения функции.
• Ссылку на предыдущий кадр стека (для навигации по стеку).
• Служебные данные рантайма Go (например, для управления горутинами).

Escape-анализ и влияние на размещение

Компилятор Go решает, где разместить переменную, на основе escape-анализа. Примеры, когда переменная «убегает» (escape) в кучу:

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

Пример escape в кучу:

func escapeExample() *int {
    x := 100 // x "убегает", так как возвращается указатель на него
    return &x // x будет размещён в куче
}

Проверить escape-анализ можно с помощью флага компилятора:

go build -gcflags="-m" main.go

Ограничения и особенности стека в Go

1. Динамический размер стека:

   • Каждая горутина начинается с небольшого стека (обычно 2 КБ).
   • Стек может динамически расти и сокращаться по мере необходимости (в отличие от фиксированного стека в некоторых языках).

2. Отсутствие переполнения стека (stack overflow) в традиционном смысле:

   • Go использует сегментированные стеки или continuous stacks (в современных версиях), что позволяет избежать классических переполнений за счёт динамического выделения новой памяти при необходимости.

3. Разделение между стеком и кучей прозрачно для разработчика:

   • В Go нет ключевых слов new или malloc для явного выделения в куче (кроме new(), но он также использует escape-анализ). Размещение автоматически определяется компилятором.

Сравнение с кучей

Заключение

В стеке Go хранятся локальные переменные, аргументы функций, возвращаемые значения и служебная информация вызовов, при условии, что их время жизни ограничено текущей функцией. Ключевую роль играет escape-анализ компилятора, который решает, может ли переменная безопасно разместиться в стеке или должна быть выделена в куче. Это позволяет оптимизировать производительность, минимизируя нагрузку на сборщик мусора, но требует понимания, как управляется память в Go. Для эффективной разработки важно учитывать эти аспекты, особенно при работе с высоконагруженными приложениями.