ARC: mi ez, az Automatic Reference Counting működési elve iOS-ben

Mi az ARC?

ARC (Automatic Reference Counting) — egy fordítói szintű memóriakezelő mechanizmus, amelyet az Apple vezetett be az Xcode 4.2-ben (2011) az Objective-C számára, és a Swift örökölte. Ellentétben a kézi memóriakezeléssel (Manual Retain-Release, MRR), az ARC teljesen automatizálja a retain, release és autorelease hívásokat, beillesztve azokat a fordítás szakaszaiban a fejlesztő részvétele nélkül.

Az ARC nem garbage collector. Ez egy statikus elemzés dinamikus kódbeillesztéssel: a fordító elemzi az objektumok élettartamát és retain/release-t helyez azokon a pontokon, ahol az objektumokat létrehozzák, másolják vagy elhagyják a láthatósági tartományt. Az eredmény — determinisztikus memóriafelszabadítás: az objektum pontosan abban a pillanatban törlődik, amikor már nem hivatkoznak rá, késleltetés és szünetek nélkül.

A WWDC 2011 Session 323 szerint az MRR-ről ARC-re váltás 70%-kal csökkentette a memóriával kapcsolatos crash-hibák számát az Apple alkalmazásaiban. A fejlesztők abbahagyták a retain/release kézi egyensúlyozását, ami megszüntette a memóriaszivárgások és double-free hibák egy teljes osztályát.

Hogyan működik az Automatic Reference Counting

Minden objektumnak a memóriában van egy referenciaszámlálója (retain count). Az objektum létrehozásakor a számláló 1-re állítődik. Amikor egy új strong-referencia mutat az objektumra — a számláló nő (retain). Amikor a strong-referencia eltűnik — a számláló csökken (release). Amikor eléri a nullát, az objektum azonnal felszabadul.

A Swift fordító nem minden hozzárendelésnél illeszt be retain/release-t — statikus elemzést használ az optimalizáláshoz. Például, ha egy objektum garanciálisan nem használódik átadás után, a fordító kihagyhatja a felesleges release/retain-t. Ezt az optimalizálást ARC Optimisation-nak hívják.

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) inicializálva (retain count: 1)")
    }
    deinit {
        print("\(name) felszabadítva")
    }
}

func testARC() {
    let p = Person(name: "Alice")  // retain count = 1
    let q = p                      // retain count = 2
    // q elhagyja a tartományt
    // retain count = 1
    // p elhagyja a tartományt
    // retain count = 0 → deinit
}

Ebben a példában látható, hogyan kezeli az ARC a számlálót: a q = p hozzárendelésnél a számláló nő, amikor q elhagyja a tartományt — csökken. Amikor az utolsó strong-referencia eltűnik, a deinicializátor azonnal meghívódik. Egyetlen garbage collector sem vár — a memória azonnal felszabadul.

ARC vs Garbage Collection: fő különbségek

Az ARC és a Garbage Collection ugyanazt a feladatot oldja meg — automatikus memóriakezelés — de alapvetően különböző megközelítésekkel. A közöttük való választás meghatározza a nyelv architektúráját: Swift (ARC) vs Java/Go (GC). Nézzük meg a fő különbségeket.

A fő kompromisszum: az ARC kiszámítható élettartamot és nulla szünetet biztosít, de megköveteli a fejlesztőtől a retain cycle megértését és a helyes weak/unowned választást. A GC mentesít ezek alól a gondok alól, de nem determinisztikus szünetek és egy külön szál árán.

Strong, Weak és Unowned: referenciakvalifikátorok az ARC-ben

Az ARC három típusú referenciakvalifikátort határoz meg, amelyek mindegyike eltérően befolyásolja a számlálót és az objektum életciklusát. A kvalifikátor helyes megválasztása a biztonságos memóriakezelés alapja Swiftben.

Strong

Strong — az alapértelmezett kvalifikátor. Minden strong-referencia 1-gyel növeli az objektum retain count-ját. Amíg legalább egy strong-referencia létezik, az objektum él. Az osztályok összes tulajdonsága és a lokális változók Swiftben alapértelmezetten strong-ok. A strong-referenciák tulajdonjogi kapcsolatot hoznak létre: az A objektum birtokolja a B objektumot.

Weak

Weak — referencia, amely nem növeli a retain count-ot. Az objektum felszabadulhat, még akkor is, ha egy weak-referencia mutat rá. A felszabadítás után a weak-referencia automatikusan nil-ra állítódik. A weak-referenciákat mindig var-ként deklaráljuk opcionális típussal (?). A retain cycle megtörésére használják, különösen a delegate mintában.

Unowned

Unowned — nem birtokló referencia, amely a weak-hez hasonlóan nem növeli a retain count-ot. Azonban az unowned-referencia nem állítódik nil-ra a felszabadítás után — a felszabadított objektumhoz való hozzáférés crash-t okoz. Az unowned akkor használatos, amikor garantált, hogy az objektum legalább olyan sokáig él, mint a referenciázó objektum. Tipikus forgatókönyv — closures és szülő-gyermek kapcsolatok garantált élettartammal.

class Customer {
    let name: String
    var card: CreditCard?         // strong
    init(name: String) { self.name = name }
    deinit { print("\(name) felszabadítva") }
}

class CreditCard {
    let number: String
    unowned let customer: Customer   // unowned — nem birtokol
    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Kártya \(number) felszabadítva") }
}

var customer: Customer? = Customer(name: "Bob")
customer?.card = CreditCard(number: "1234", customer: customer!)
customer = nil
// Customer és CreditCard mindkettő felszabadult — nincs retain cycle

Itt a CreditCard unowned-referenciát használ a Customer-re. A Customer birtokolja a kártyát (strong), és a kártya nem birtokolja az ügyfelet (unowned). Amikor a Customer nil lesz, mindkét objektum felszabadul — nem jön létre retain cycle. Ha a card.customer strong lett volna, a ciklus blokkolta volna a felszabadítást.

Tipikus ARC-problémák és megoldásuk

Az automatizálás ellenére az ARC nem csodaszer. A fejlesztők számos tipikus problémával találkoznak, amelyek megkövetelik a memóriakezelés belső mechanizmusának megértését.

Retain Cycle a Closures-ben

A Swiftben a closures strong-referencián keresztül fogják el a külső változókat. Ha egy closure hozzá van rendelve egy osztály tulajdonságához és elkapja a self-et — retain cycle jön létre: az osztály tartja a closure-t, a closure tartja a self-et. Megoldás — capture list weak vagy unowned használatával.

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() { }
}

A capture list [weak self] egy weak-referenciát hoz létre a self-re a closure-on belül. Ez megtöri a lehetséges retain cycle-t. A guard let self garantálja, hogy az objektum él a kód végrehajtása előtt. A weak self — standard gyakorlat az aszinkron closures esetében Swiftben.

Retain/Release teljesítmény

Bár a retain/release könnyű műveletek, a gyakori számláló növelése/csökkentése forró ciklusokban többletterhelést okoz. A Swift 5.9+-ban a fordító optimalizálást használ, amelyben a felesleges retain/release-t eltávolítják, ha az elemző bizonyítani tudja a biztonságot. Azonban az Objective-C-ben a retain/release továbbra is szűk keresztmetszet lehet a nagy terhelésű forgatókönyvekben, ahol másodpercenként milliók a hívások.

Autorelease Pool

Autorelease Pool — késleltetett release mechanizmus, amelyet az Objective-C-ben és néhány Swift-forgatókönyvben használnak. Az objektumok egy pool-ba kerülnek, és a pool kiürítésekor kapnak release-t. A sok ideiglenes objektumot tartalmazó ciklusokban (például JSON elemzés) a saját autoreleasepool létrehozása csökkenti az operatív memória csúcsfogyasztását.