Как стек очищается?

Как очищается стек вызовов в iOS (Swift/Objective-C)

Очистка стека вызовов — это фундаментальный процесс управления памятью и потоком выполнения в iOS-приложениях. Давайте разберем этот процесс детально.

Что такое стек вызовов

Стек вызовов (call stack) — это структура данных LIFO (Last In, First Out), которая хранит информацию о активных функциях и методах во время выполнения программы. Каждая запись в стеке называется кадром стека (stack frame) и содержит:

• Локальные переменные функции
• Аргументы, переданные в функцию
• Адрес возврата (куда вернуться после завершения функции)
• Другие служебные данные

Механизм очистки стека

Очистка происходит автоматически при завершении выполнения функции/метода:

func calculateSum(a: Int, b: Int) -> Int {
    let result = a + b  // Локальная переменная создается в кадре стека
    return result       // Кадр стека очищается после return
}

func main() {
    let x = 5           // Кадр для main() создается
    let y = 10
    let sum = calculateSum(a: x, b: y)  // Новый кадр для calculateSum
    
    // После возврата из calculateSum ее кадр УДАЛЯЕТСЯ из стека
    print(sum)          // В стеке остается только кадр main()
}

Ключевые аспекты очистки

1. Автоматическое управление

Стек очищается автоматически компилятором и рантаймом:

• При достижении return в функции
• При выходе из области видимости
• При выбрасывании и обработке исключений

2. Порядок очистки (LIFO)

func functionA() {
    functionB()  // 1. functionB добавляется в стек
    // 3. После functionB, ее кадр удаляется
}

func functionB() {
    functionC()  // 2. functionC добавляется в стек
    // 2.1. functionC завершается, ее кадр удаляется
}

3. Особенности с исключениями

При использовании try-catch или do-catch, стек очищается особым образом:

func riskyOperation() throws {
    let resource = allocateResource()  // Создается в стеке
    
    defer {
        cleanup(resource)  // Выполнится ПЕРЕД очисткой кадра
    }
    
    if somethingWrong {
        throw MyError.failure  // Кадр очищается после throw
    }
}

Отличия от кучи (Heap)

Важно понимать разницу между очисткой стека и кучи:

class MyClass {
    var data: [Int] = []  // Хранится в КУЧЕ
}

func example() {
    var localVar = 42          // В СТЕКЕ - очистится автоматически
    let object = MyClass()     // ССЫЛКА в стеке, ДАННЫЕ в куче
    
    object.data.append(1)      // Данные в куче
    
    // После выхода из функции:
    // - localVar очищается (стек)
    // - ссылка object очищается (стек)
    // - Сам object удаляется из кучи ТОЛЬКО если нет других ссылок (ARC)
}

Особенности в многопоточности

Каждый поток имеет собственный стек:

DispatchQueue.global().async {
    // Этот блок выполняется в отдельном потоке
    // с ОТДЕЛЬНЫМ стеком вызовов
    performTask()  // Создает свой кадр стека в этом потоке
    
    // По завершении блок очищает свой стек
}

Процесс очистки шаг за шагом

1. Определение точки выхода

   • Компилятор вставляет код для очистки при компиляции
   • Определяются все локальные переменные, которые нужно уничтожить

2. Уничтожение объектов

   • Для значимых типов (value types): простое освобождение памяти
   • Для ссылочных типов (reference types): уменьшение счетчика ссылок ARC

3. Восстановление состояния

   • Восстанавливается указатель стека (stack pointer)
   • Восстанавливается указатель кадра (frame pointer)
   • Переход по адресу возврата

4. Продолжение выполнения

   • Управление возвращается вызывающей функции
   • Новый верхний кадр становится активным

Пример с вложенными вызовами

func level3() {
    let z = 30
    print("Level 3: \(z)")
    // 3. Кадр level3 очищается, z уничтожается
}

func level2() {
    let y = 20
    level3()
    // 2. Кадр level2 очищается, y уничтожается
}

func level1() {
    let x = 10
    level2()
    // 1. Кадр level1 очищается, x уничтожается
}

Оптимизации компилятора

Современные компиляторы применяют оптимизации:

• Inline-подстановка функций: устраняет накладные расходы на вызов
• Оптимизация хвостовой рекурсии: повторно использует кадр стека
• Свёртывание констант: вычисляет значения на этапе компиляции

Практическое значение

Понимание очистки стека критически важно для:

• Отладки сложных падений приложения
• Оптимизации производительности (избегание глубокой рекурсии)
• Понимания управления памятью в iOS
• Работы с асинхронным кодом и completion-блоками

Главный принцип: стек вызовов — это автоматически управляемая структура, где очистка происходит предсказуемо и детерминировано по принципу LIFO, в отличие от кучи, где памятью управляет ARC и возможны более сложные сценарии.