Как работает Garbage Collectors в Swift?

Принципы работы ARC (Automatic Reference Counting) в Swift

В Swift для управления памятью используется Automatic Reference Counting (ARC), а не традиционный garbage collector (как в Java или C#). ARC — это компиляторная технология, которая автоматически вставляет код подсчёта ссылок во время компиляции.

Основной механизм работы

ARC работает по принципу подсчёта ссылок:

• Каждый объект имеет счётчик активных ссылок
• При создании сильной ссылки счётчик увеличивается на 1
• При уничтожении ссылки счётчик уменьшается на黄豆
• Когда счётчик достигает 0, память немедленно освобождается

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) создан")
    }
    deinit {
        print("\(name) уничтожен")
    }
}

// Пример работы ARC
var person1: Person? = Person(name: "Анна")  // Счётчик = 1
var person2: Person? = person1              // Счётчик = 2

person1 = nil                               // Счётчик = 1
person2 = nil                               // Счётчик = 0 -> вызов deinit

Типы ссылок в Swift

1. Сильные ссылки (Strong references)

• Увеличивают счётчик ссылок
• По умолчанию все ссылки сильные
• Могут создавать циклы удержания

2. Слабые ссылки (Weak references)

• Не увеличивают счётчик ссылок
• Автоматически становятся nil при освобождении объекта
• Всегда объявляются как optional (weak var)

class Apartment {
    weak var tenant: Person?  // Слабая ссылка
}

3. Бессодержательные ссылки (Unowned references)

• Не увеличивают счётчик ссылок
• Не становятся nil (предполагается, что объект живёт дольше)
• Не optional, но приводят к crash при обращении к освобождённому объекту

class Customer {
    unowned let card: CreditCard  // Бессодержательная ссылка
}

Проблема циклических ссылок и её решение

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

// Проблемный код с циклом удержания
class Person {
    var apartment: Apartment?
}

class Apartment {
    var tenant: Person?
}

var john: Person? = Person()
var unit4A: Apartment? = Apartment()

john!.apartment = unit4A  // Счётчик Apartment = 2
unit4A!.tenant = john     // Счётчик Person = 2

// Даже после nil объекты не освобождаются!
john = nil      // Счётчик Person = 1
unit4A = nil    // Счётчик Apartment = 1

Решение — использовать weak или unowned:

class Apartment {
    weak var tenant: Person?  // Теперь цикл разорван
}

Особенности реализации ARC

Преимущества перед традиционным GC:

1. Детерминированное освобождение — память освобождается сразу при счётчике 0
2. Нет пауз (stop-the-world) — не требуется приостанавливать выполнение программы
3. Предсказуемая производительность — нет непредсказуемых сборок мусора
4. Минимальные накладные расходы — работа происходит во время компиляции

Недостатки:

1. Необходимость ручного управления ссылками — программист должен явно указывать weak/unowned
2. Возможность ошибок с unowned — доступ к освобождённой памяти
3. Сложность с графами объектов — требуется тщательный анализ ссылочных зависимостей

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

Когда использовать weak:

• При обратных ссылках (делегаты, обратные вызовы)
• В отношениях родитель-ребёнок, где ребёнок не должен удерживать родителя
• В асинхронных операциях, захватывающих self

class NetworkManager {
    weak var delegate: NetworkDelegate?
    
    func fetchData(completion: @escaping () -> Void) {
        // weak self для избежания цикла в closure
        someAsyncOperation { [weak self] in
            guard let self = self else { return }
            self.delegate?.didReceiveData()
            completion()
        }
    }
}

Когда использовать unowned:

• Когда объект точно переживает зависимый объект
• В отношениях, где время жизни строго определено
• Для небольших оптимизаций производительности (меньше накладных расходов, чем weak)

Сравнение с другими системами управления памятью

Заключение

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

Для успешной работы с ARC необходимо:

1. Понимать модель владения в своём приложении
2. Использовать weak для потенциальных циклов
3. Применять unowned только при гарантированном времени жизни
4. Регулярно проверять код на наличие retain cycles с помощью инструментов профилирования

ARC — это мощная система, которая при правильном использовании обеспечивает оптимальное управление памятью без потерь производительности, характерных для runtime garbage collection.