Как система понимает, когда освобождать объекты, а когда выделять под них память?

Управление памятью в iOS: принципы выделения и освобождения объектов

В экосистеме Apple (iOS, macOS) для управления памятью объектов исторически использовались две ключевые технологии: счетчик ссылок (MRC) и автоматический подсчет ссылок (ARC). Сейчас ARC является стандартом де-факто, но понимание обеих систем важно для глубокого понимания работы памяти.

Основные механизмы управления памятью

1. Ручное управление (MRC — Manual Reference Counting)

До iOS 5 разработчики вручную управляли жизненным циклом объектов:

// Objective-C с MRC
NSObject *obj = [[NSObject alloc] init]; // retainCount = 1
[obj retain]; // retainCount = 2
[obj release]; // retainCount = 1
[obj release]; // retainCount = 0 → объект уничтожается

Принцип работы: каждый объект имеет внутренний счетчик ссылок. При создании через alloc/init счетчик = 1. Методы retain и release увеличивают/уменьшают счетчик. Когда счетчик достигает нуля, система вызывает dealloc и освобождает память.

2. Автоматический подсчет ссылок (ARC — Automatic Reference Counting)

Начиная с iOS 5, компилятор автоматически вставляет вызовы retain/release:

// Swift с ARC
class Example {
    var value: String
    
    init(value: String) {
        self.value = value // Компилятор автоматически управляет памятью
    }
}

func createObject() {
    let obj = Example(value: "test") // retainCount = 1
    // При выходе из функции retainCount уменьшается до 0
    // Объект автоматически освобождается
}

Ключевое отличие: разработчик работает с сильными (strong), слабыми (weak) и бесхозными (unowned) ссылками, а компилятор генерирует соответствующий код управления памятью.

Как система определяет момент освобождения

Правила работы ARC:

• Сильная ссылка (strong) увеличивает retainCount на 1
• Слабая ссылка (weak) не увеличивает счетчик, автоматически становится nil при освобождении объекта
• Бесхозная ссылка (unowned) не увеличивает счетчик, но предполагает, что объект существует

class Parent {
    var child: Child? // Сильная ссылка
    weak var delegate: DelegateProtocol? // Слабая ссылка (избегает цикла ссылок)
}

class Child {
    unowned let parent: Parent // Бесхозная ссылка (parent должен существовать дольше child)
}

Алгоритм принятия решения:

1. Компилятор анализирует код и определяет точки, где объект начинает и заканчивает использоваться
2. Во время выполнения среда отслеживает количество сильных ссылок на каждый объект
3. Когда счетчик достигает нуля, система:
   • Вызывает деструктор (deinit в Swift, dealloc в Objective-C)
   • Помечает память как свободную
   • При необходимости выполняет деаллокацию

Циклы ссылок и их разрешение

Цикл ссылок — основная проблема ARC, когда два объекта удерживают друг друга сильными ссылками:

class A {
    var b: B?
}

class B {
    var a: A?
}

func createCycle() {
    let a = A()
    let b = B()
    a.b = b // Сильная ссылка
    b.a = a // Сильная ссылка → цикл!
    // Оба объекта никогда не освободятся
}

Способы решения:

• Использование weak для одной из ссылок
• Использование unowned когда время жизни объекта известно
• Передача closure как [weak self] или [unowned self]

Особенности Swift и Objective-C

В Swift:

• Структуры (struct) и перечисления (enum) хранятся в стеке и не требуют подсчета ссылок
• Классы (class) размещаются в куче и управляются через ARC
• Оптимизации компилятора, такие как exclusive access to memory, предотвращают ненужные удержания

В Objective-C с ARC:

• Автоматическая вставка retain/release/autorelease
• Возможность использовать Autorelease Pool для группового управления объектами

Практические рекомендации

1. Профилирование памяти: используйте Instruments (Leaks, Allocations) для поиска утечек
2. Шаблоны проектирования: делегаты должны быть weak, а зависимости в родительских объектах — unowned
3. Работа с асинхронным кодом: всегда явно указывайте [weak self] в замыканиях, которые могут создать retain cycles

Вывод: Система понимает, когда освобождать объекты, через механизм подсчета сильных ссылок, автоматически управляемый компилятором. Разработчику необходимо правильно проектировать отношения между объектами, используя weak/unowned ссылки там, где возможны циклы. Современный ARC сочетает автоматизацию с предсказуемостью, но требует понимания его внутренних механизмов для написания эффективного и стабильного кода.