Как осуществляется управление памятью для ссылочных типов в Swift?

Управление памятью для ссылочных типов в Swift осуществляется автоматически с помощью Automatic Reference Counting (ARC).

ARC отслеживает и управляет strong-ссылками на экземпляры классов. Когда количество strong-ссылок на экземпляр становится равно нулю, ARC deallocates (освобождает) память, занимаемую этим экземпляром.

Однако, ARC не полностью исключает ручное управление памятью в некоторых случаях, таких как:

1. Strong Reference Cycles (Циклы сильных ссылок): Два или более экземпляра классов могут иметь сильные ссылки друг на друга, предотвращая их deallocation даже при отсутствии внешних ссылок. Для решения этой проблемы используются:

   • Weak References (Слабые ссылки): Используются для ссылок, которые могут стать nil. Не увеличивают счетчик strong-ссылок. Объявляются с ключевым словом weak.
   • Unowned References (Бесхозные ссылки): Используются для ссылок, которые гарантированно всегда имеют значение (не могут стать nil). Не увеличивают счетчик strong-ссылок. Объявляются с ключевым словом unowned. Могут привести к крэшу при доступе, если объект уже был deallocated.

2. Capturing Lists (Списки захвата) в замыканиях: Замыкание может "захватывать" strong-ссылку на экземпляр, с которым оно взаимодействует, потенциально создавая цикл ссылок, если замыкание также хранится экземпляром. Для избежания этого используются списки захвата ([weak self], [unowned self]) для явного указания, как захватываются ссылки.

Пример слабого захвата в замыкании:

class Person {
    let name: String
    var apartment: Apartment?

    init(name: String) { self.name = name }
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    weak var tenant: Person? // Weak reference

    init(unit: String) { self.unit = unit }
    deinit { print("Apartment \(unit) is being deinitialized") }
}

var john: Person? = Person(name: "John Appleseed")
var unit4A: Apartment? = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

john = nil
unit4A = nil
// Вывод в консоль:
// John Appleseed is being deinitialized
// Apartment 4A is being deinitialized
// Оба объекта были deallocated благодаря weak-ссылке.

Пример бесхозного захвата в замыкании:

class HTMLElement {
    let name: String
    let text: String?

    lazy var asHTML: () -> String = {
        [unowned self] in // Unowned capture
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name)>"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

var heading: HTMLElement? = HTMLElement(name: "h1")
let defaultText = "Lorem ipsum"
heading!.asHTML = {
    [unowned heading] in // Unowned capture in a closure also held by the instance
    if let heading = heading {
        return "<\(heading.name)>\(defaultText)</\(heading.name)>"
    } else {
        return "Error: element gone."
    }
}

heading!.asHTML() // Access the closure

heading = nil
// Вывод в консоль:
// h1 is being deinitialized

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