ARC: какво е, принцип на работа на Automatic Reference Counting в iOS

Какво е ARC?

ARC (Automatic Reference Counting) — е механизъм за управление на паметта на ниво компилатор, въведен от Apple в Xcode 4.2 (2011) за Objective-C и унаследен от Swift. За разлика от ръчното управление на паметта (Manual Retain-Release, MRR), ARC пълностий автоматизира позиванията retain, release и autorelease, вмъквайки ги на етапа на компилацията без участието на разработчика.

ARC не е garbage collector. Това е статичен анализ с динамично вмъкване на код: компилаторът анализира живота на обектите и поставя retain/release в точките, където обектите се създават, копират или напускат обхвата. Резултатът — детерминистично освобождаване на паметта: обектът се изтрива точно в момента, когато вече няма референции към него, без забавяне и паузи.

Според WWDC 2011 Session 323, преходът от MRR към ARC намали броя на crash-грешките, свързани с паметта, с 70% в приложенията на Apple. Разработчиците спряха да балансират ръчно retain/release, което елиминира цял клас от изтичания и double-free грешки.

Как работи Automatic Reference Counting

Всяка обект в паметта има брояч на референции (retain count). При създаването на обекта, броячът се задава на 1. Когато нова strong-референция сочи към обекта — броячът се увеличава (retain). Когато strong-референцията изчезне — броячът намалява (release). При достигане на нула, обектът се освобождава незабавно.

Swift компилаторът не вмъква retain/release при всяко присвояване — той използва статичен анализ за оптимизация. Например, ако обектът е гарантирано да не се използва след пренасяне, компилаторът може да прескочи излишния release/retain. Тази оптимизация се нарича ARC Optimisation.

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) инициализиран (retain count: 1)")
    }
    deinit {
        print("\(name) освободен")
    }
}

func testARC() {
    let p = Person(name: "Alice")  // retain count = 1
    let q = p                      // retain count = 2
    // q напуска обхвата
    // retain count = 1
    // p напуска обхвата
    // retain count = 0 → deinit
}

В този пример се вижда как ARC управлява брояча: при присвояване q = p, броячът се увеличава, при напускане на обхвата от q — намалява. Когато последната strong-референция изчезне, деинициализаторът се извиква незабавно. Никакъв garbage collector не чака — паметта се освобождава незабавно.

ARC срещу Garbage Collection: ключови разлики

ARC и Garbage Collection решават една и съща задача — автоматично управление на паметта — но с основно различни подходи. Изборът между тях определя архитектурата на езика: Swift (ARC) срещу Java/Go (GC). Нека разгледаме основните разлики.

Ключовият компромис: ARC предоставя предвидим живот на обектите и нулеви паузи, но изисква от разработчика разбиране на retain cycle и правилен избор на weak/unowned. GC освобождава от тези притеснения, но цената е недетерминирани паузи и допълнителна нишка.

Strong, Weak и Unowned: квалификатори на референциите в ARC

ARC определя три типа квалификатори на референциите, всяка от които повлиява различно на брояча и животения цикъл на обекта. Правилният избор на квалификатор е основата на безопасната работа с памет в Swift.

Strong

Strong — квалификаторът по подразбиране. Всяка strong-референция увеличава retain count на обекта с 1. Докато съществува поне една strong-референция, обектът е жив. Всички свойства на класовете и локалните променливи в Swift са по подразбиране strong. Strong-референциите създават отношение на собственост: обект A притежава обект B.

Weak

Weak — референция, която не увеличава retain count. Обектът може да бъде освободен, дори ако weak-референция сочи към него. След освобождаване, weak-референцията автоматично се задава на nil. Weak-референциите винаги се декларират като var с незадължителен тип (?). Те се използват за прекъсване на retain cycle, особено в delegate модела.

Unowned

Unowned — непритежаваща референция, която като weak не увеличава retain count. Обаче unowned-референцията не се задава на nil след освобождаване — достъпът до освободен обект причинява crash. Unowned се използва, когато е гарантирано, че обектът живее поне толкова дълго, колкото и рефериращият обект. Типично сценарий — затварянета (closures) и отношения родител-деца с гарантиран живот.

class Customer {
    let name: String
    var card: CreditCard?         // strong
    init(name: String) { self.name = name }
    deinit { print("\(name) освободен") }
}

class CreditCard {
    let number: String
    unowned let customer: Customer   // unowned — не притежава
    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Карта \(number) освободена") }
}

var customer: Customer? = Customer(name: "Bob")
customer?.card = CreditCard(number: "1234", customer: customer!)
customer = nil
// Customer и CreditCard и двата освободени — няма retain cycle

Тук CreditCard използва unowned-референция към Customer. Customer притежава картата (strong), а картата не притежава клиента (unowned). Когато Customer стане nil, и двата обекта се освобождават — не се появява retain cycle. Ако card.customer беше strong, цикълът щеше блокирал освобождаването.

Типични проблеми на ARC и тяхното решаване

Независимо от автоматизацията, ARC не е панацея. Разработчиците се срещат с няколко типични проблема, които изискват разбиране на вътрешния механизъм за управление на паметта.

Retain Cycle в затваряния

Затварянията (closures) в Swift улавят външни променливи чрез strong-референция. Ако едно затваряне е присвоено на свойство на клас и улавя self — се появява retain cycle: класът притежава затварянето, затварянето притежава self. Решение — capture list с weak или unowned.

class NetworkManager {
    var completionHandler: ((Data?) -> Void)?
    var data: Data?

    func fetchData() {
        completionHandler = { [weak self] result in
            guard let self else { return }
            self.data = result
            self.processResult()
        }
    }

    func processResult() { }
}

Capture list [weak self] създава weak-референция към self вътре в затварянето. Това прекъсва потенциалния retain cycle. Guard let self гарантира, че обектът е жив преди изпълнението на кода. weak self — стандартна практика за асинхронни затваряния в Swift.

Производителност на retain/release

Въпреки че retain/release са леки операции, честите увеличавания/намалявания на брояча в горещи цикълове добавят допълнителна разход. В Swift 5.9+, компилаторът използва оптимизация, при която излишните retain/release се премахват, ако анализаторът може да докаже безопасност. Обаче в Objective-C retain/release все още могат да бъдат тъско място в сценарии с високо натоварване с милиони позивания на секунда.

Autorelease Pool

Autorelease Pool — механизъм за забавен освобождаване, използван в Objective-C и някои Swift сценарии. Обектите се поставят в пул и получават release при източване на пула. В цикълове с голям брой временни обекти (например, анализ на JSON), създаването на собствен autoreleasepool намалява пиковата консумация на оперативна памет.