Когда умирает переменная?

Когда умирает переменная в Swift?

В Swift переменная «умирает» — то есть её память освобождается и она становится недоступной — в момент её деаллокации. Однако это не единичный момент, а результат работы нескольких механизмов управления памятью, зависящих от типа переменной и контекста её использования.

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

Локальные переменные, созданные внутри функции или метода, уничтожаются автоматически при выходе из области их видимости, то есть когда выполнение функции завершается. Swift гарантирует это благодаря Automatic Reference Counting (ARC).

func processData() {
    let localVariable = "Hello" // переменная создана
    print(localVariable)
} // при выходе из функции localVariable уничтожается

Для переменных, хранящих объекты классов (ссылочные типы), ARC уменьшает счетчик ссылок. Если счетчик становится нулевым, объект деаллоцируется. Для значений (структуры, перечисления, базовые типы) память освобождается сразу.

2. Свойства классов и структур

• В структурах: свойства «умирают» вместе с самой структурой, когда экземпляр структуры уничтожается.
• В классах: свойства уничтожаются, когда экземпляр класса деаллоцируется ARC. Это происходит, когда на него не осталось сильных ссылок.

class MyClass {
    var property: String = "Test"
}

var instance: MyClass? = MyClass() // создается экземпляр, счетчик ссылок = 1
instance = nil // счетчик ссылок уменьшается до 0, экземпляр и его property деаллоцируются

3. Глобальные и статические переменные

Глобальные переменные и статические свойства существуют на протяжении всего жизненного цикла программы. Они «умирают» только при завершении работы программы. Их память освобождается системой.

class AppConfig {
    static let sharedValue = "Config" // существует до конца работы программы
}

4. Переменные в замыканиях (closures)

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

class DataManager {
    var completion: (() -> Void)?
    
    func setupCompletion() {
        completion = { [weak self] in // использование weak ссылки для избежания цикла
            guard let self = self else { return }
            print(self)
        }
    }
}

5. Основные правила деаллокации ARC

ARC — это не сборка мусора, а компиляторный механизм. Он автоматически добавляет код для управления счетчиком ссылок:

• Сильная ссылка (strong) увеличивает счетчик на 1.
• Слабая ссылка (weak) и ссылка без владения (unowned) не увеличивают счетчик.
• Когда счетчик сильных ссылок достигает нуля, Swift вызывает деинициализатор (deinit) и освобождает память.

Ключевые моменты смерти переменной:

• Для ссылочных типов (classes): смерть — это деаллокация экземпляра в памяти после deinit.
• Для значимых типов (structs, enums, primitives): смерть — это непосредственное освобождение их памяти при выходе из контекста, так как они хранятся в стеке или внутри других объектов.
• Управление памятью в Swift преимущественно автоматическое, но разработчик должен контролировать ссылочные циклы через weak и unowned.

Таким образом, переменная «умирает» когда система управления памятью (в основном ARC) определяет, что она больше не нужна и безопасно удаляет её из памяти. Для избежания утечек памяти и корректной работы приложения важно понимать эти механизмы и правильно использовать типы ссылок в сложных объектных моделях.