ARC: bu nima, Automatic Reference Counting iOS da ishlash prinsipi

ARC nima?

ARC (Automatic Reference Counting) — bu Apple tomonidan Xcode 4.2 (2011) da Objective-C uchun taqdim etilgan va Swift tomonidan meros qilib olingan kompilyator xotira boshqaruv mexanizmidir. Qoʻl bilan xotira boshqaruvidan (Manual Retain-Release, MRR) farqli oʻlaroq, ARC retain, release va autorelease chaqiruvlarini toʻliq avtomatlashtiradi, ularni kompilyatsiya bosqichida dasturchi ishtirokisiz joylashtiradi.

AR C garbage collector emas. Bu dinamik kod joylashtirish bilan statik tahlil: kompilyator obyektlarning umr muddatini tahlil qiladi va obyektlar yaratilgan, nusxalangan yoki koʻrinish doirasidan chiqqan nuqtalarda retain/release joylashtiradi. Natija — deterministik xotira boʻshatilishi: obyekt unga havolalar toʻxtaganda aynan oʻsha paytda, kechikishlar va pauzalarsiz oʻchiriladi.

WWDC 2011 Session 323 maʻlumotlariga koʸra, MRR dan ARC ga oʻtish Apple ilovalarida xotira bilan bogʻli crash-baglar sonini 70% ga kamaytirdi. Dasturchilar qoʻl bilan retain/release muvozanatini saqlashni toʻxtatdilar, bu butun bir sinf oqish va double-free xatolarini bartaraf etdi.

Automatic Reference Counting qanday ishlaydi

Xotiradagi har bir obyektning referans hisoblagichi (retain count) bor. Obyekt yaratilganda hisoblagich 1 ga oʻrnatiladi. Yangi strong-referans obyektga ishora qilganda — hisoblagich ortadi (retain). Strong-referans yoʻqolganda — hisoblagich kamayadi (release). Nolga yetganda obyekt darhol dealokatsiya qilinadi.

Swift kompilyatori retain/release ni har bir tayinlashda emas — optimallashtirish uchun statik tahlildan foydalanadi. Masalan, agar obyekt uzatilgandan keyin foydalanilmasligi kafolatlangan boʻlsa, kompilyator ortiqcha release/retain ni oʻtkazib yuborishi mumkin. Bu optimallashtirish ARC Optimisation deb ataladi.

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) ishga tushirildi (retain count: 1)")
    }
    deinit {
        print("\(name) dealokatsiya qilindi")
    }
}

func testARC() {
    let p = Person(name: "Alice")  // retain count = 1
    let q = p                      // retain count = 2
    // q doiradan chiqadi
    // retain count = 1
    // p doiradan chiqadi
    // retain count = 0 → deinit
}

Ushbu misolda ARC hisoblagichni qanday boshqarishi koʻrinadi: q = p tayinlanganda hisoblagich ortadi, q doira dan chiqqanda — kamayadi. Oxirgi strong-referans yoʻqolganda deinitsializator darhol chaqiriladi. Hech qanday garbage collector kutmaydi — xotira darhol boʻshatiladi.

ARC vs Garbage Collection: asosiy farqlar

ARC va Garbage Collection bir xil vazifani — avtomatik xotira boshqaruvini — hal qiladi, lekin tubdan farqli yondashuvlar bilan. Ularning oʻrtasidagi tanlov til arxitekturasini belgilaydi: Swift (ARC) vs Java/Go (GC). Keling, asosiy farqlarni koʻrib chiqaylik.

Asosiy kompromis: ARC obyektlarning bashorat qilinadigan umr muddatini va nol pauzalarni taʻminlaydi, lekin dasturchidan retain cycle tushunchasini va toʻgʻri weak/unowned tanlashni talab qiladi. GC bu tashvishlardan xalos qiladi, ammo nodeterministik pauzalar va qoʻshimcha ip evaziga.

Strong, Weak va Unowned: ARC da referans kvalifikatorlari

ARC uch turdagi referans kvalifikatorini belgilaydi, ularning har biri hisoblagichga va obyektning hayot aylanishiga turlicha taʻsir qiladi. Kvalifikatorni toʻgʻri tanlash Swift da xavfsiz xotira bilan ishlashning asosidir.

Strong

Strong — standart kvalifikator. Har bir strong-referans obyektning retain count ini 1 ga oshiradi. Hech boʻlmaganda bitta strong-referans mavjud ekan, obyekt tirik. Swift dagi barcha sinf xususiyatlari va lokal oʻzgaruvchilar standart holda strong dir. Strong-referanslar egalik munosabatini yaratadi: A obyekti B obyektiga ega.

Weak

Weak — retain count ni oshirmaydigan referans. Obyekt weak-referans unga ishora qilsa ham dealokatsiya qilinishi mumkin. Dealokatsiyadan keyin weak-referans avtomatik ravishda nil ga oʻrnatiladi. Weak-referanslar har doim ixtiyoriy tip bilan (?) var sifatida eʻlon qilinadi. Ular retain cycle ni buzish uchun, ayniqsa delegate namunasida ishlatiladi.

Unowned

Unowned — weak kabi retain count ni oshirmaydigan egasiz referans. Biroq unowned-referans dealokatsiyadan keyin nil ga oʻrnatilmaydi — boʻshatilgan obyektga murojaat crash ga sabab boʻladi. Unowned obyektning referans qiluvchi obyektdan kamida shuncha yashashi kafolatlanganida ishlatiladi. Tipik stsenariy — yopilishlar (closures) va kafolatlangan umr muddati bilan ota-bola munosabatlari.

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

class CreditCard {
    let number: String
    unowned let customer: Customer   // unowned — ega emas
    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Karta \(number) dealokatsiya qilindi") }
}

var customer: Customer? = Customer(name: "Bob")
customer?.card = CreditCard(number: "1234", customer: customer!)
customer = nil
// Customer va CreditCard ikkalasi ham boʻshatildi — retain cycle yoʻq

Bu yerda CreditCard Customer ga unowned-referansdan foydalanadi. Customer kartaga ega (strong), karta esa mijozga ega emas (unowned). Customer nil boʻlganda ikkala obyekt ham boʻshatiladi — retain cycle yuz bermaydi. Agar card.customer strong boʻlganida, sikl boʻshatishni bloklagan boʻlardi.

ARC ning tipik muammolari va ularni hal qilish

Avtomatlashtirishga qaramay, ARC panatseya emas. Dasturchilar xotira boshqaruvining ichki mexanizmini tushunishni talab qiladigan bir necha tipik muammolarga duch kelishadi.

Yopilishlarda Retain Cycle

Swift dagi yopilishlar (closures) tashqi oʻzgaruvchilarni strong-referans orqali tutib oladi. Agar yopilish sinf xususiyatiga tayinlansa va self ni tutib olsa — retain cycle yuzaga keladi: sinf yopilishni, yopilish self ni ushlab turadi. Yechim — weak yoki unowned bilan capture list.

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] yopilish ichida self ga weak-referans yaratadi. Bu potensial retain cycle ni buzadi. Guard let self kodni bajarishdan oldin obyektning tirikligini kafolatlaydi. weak self — Swift da asinxron yopilishlar uchun standart amaliyot.

Retain/Release unumdorligi

Retain/release yengil operatsiyalar boʻlsada, qaynoq sikllarda tez-tez hisoblagichni oshirish/kamaytirish qoʻshimcha yuk hosil qiladi. Swift 5.9+ da kompilyator optimallashtirish dan foydalanadi, bunda tahlilchi xavfsizlikni isbotlasa, ortiqcha retain/release lar olib tashlanadi. Biroq Objective-C da retain/release sekundiga millionlab chaqiruvlar bilan yuqori yuklangan stsenariylarda hali ham tor boʻgʻz boʻlishi mumkin.

Autorelease Pool

Autorelease Pool — Objective-C va Swift ning baʻzi stsenariylarida ishlatiladigan kechiktirilgan release mexanizmi. Obyektlar hovuzga joylashtiriladi va hovuz toʻkilganda release oladi. Koʻp sonli vaqtinchalik obyektlari boʻlgan sikllarda (masalan, JSON tahlil qilish) oʻz autoreleasepool yaratish operativ xotiraning eng yuqori isteʻmolini kamaytiradi.