Aktor — bu nima, ma'lumot izolyatsiyasi va parallellik

Swift'da Actor nima?

Actor — sinfga o'xshash, ammo ma'lumot poygalaridan avtomatik himoya bilan mos yozuvlar turidir. Swift 5.5 da async/await va Task bilan birga parallellik tizimining bir qismi sifatida taqdim etilgan. Actor o'zining o'zgaruvchan holati hech qachon aniq sinxronizatsiyasiz turli iplardan bir vaqtning o'zida o'qilmasligi yoki yozilmasligini kafolatlaydi.

Actor e'lon qilish sintaksisi

Aktorni e'lon qilish uchun actor kalit so'zi ishlatiladi, undan keyin uning a'zolari bilan figurali qavslar keladi. Sintaktik jihatdan aktor sinfga o'xshaydi, ammo xatti-harakati tubdan farq qiladi.

actor BankAccount {
    private var balance: Double
    
    init(initialBalance: Double) {
        self.balance = initialBalance
    }
    
    func deposit(amount: Double) {
        balance += amount
    }
    
    func getBalance() -> Double {
        return balance
    }
}

Kompilyator aktorning barcha xususiyatlari va metodlarini avtomatik ravishda izolyatsiya qiladi, shuning uchun ular faqat aktor konteksti ichida mavjud bo'ladi. Aktordan tashqarida balance-ga kirishga urinish, agar chaqiruv async deb belgilanmagan bo'lsa, kompilyator xatosiga olib keladi.

Actor'da ma'lumot izolyatsiyasi qanday ishlaydi

Ma'lumot izolyatsiyasi — aktorning asosiy kontseptsiyasidir. Actor o'z holatiga o'zaro eksklyuziv kirishni aktor ijrochisi (actor executor) mexanizmi orqali kafolatlaydi. Har bir aktor o'zining ijrochisiga ega bo'lib, u uning izolyatsiya qilingan a'zolariga barcha murojaatlarni ketma-ket qayta ishlaydi.

Izolyatsiyaning ishlash printsipi

Aktordan tashqaridagi kod uning metodini chaqirganda, chaqiruv aktor ijrochisi navbatiga joylashtiriladi. Actor bir vaqtning o'zida faqat bitta vazifani bajaradi, bu poygalarning yo'qligini kafolatlaydi. Agar ikkita ip bir vaqtning o'zida deposit-ni chaqirsa, ikkinchi chaqiruv birinchisining tugashini kutadi.

let account = BankAccount(initialBalance: 1000.0)
// Asinxron chaqiruv — aktor tashqarisidan talab qilinadi
await account.deposit(amount: 500.0)
let currentBalance = await account.getBalance()

Aktor metodining har bir chaqiruvi await talab qiladi, chunki aktor boshqa vazifa bilan band bo'lishi mumkin. Bu xato emas, balki poygalarning oldini oluvchi ongli dizayndir. Swift aktor xususiyatlarining getter va setterlarini bilvosita async qiladi, shuning uchun xususiyatni o'qish ham await talab qiladi.

Actor va sinf o'rtasidagi asosiy farqlar

Actor va sinf mos yozuvlar turlaridir, ammo ularning ko'p ipli muhitdagi xatti-harakati tubdan farq qiladi. Sinf poygalarga qarshi hech qanday avtomatik himoyani ta'minlamaydi, holbuki aktor uni tip tizimi orqali kompilyator darajasida o'rnatadi.

Aktor merosi

Aktor faqat boshqa aktordan meros olishi mumkin va sinfdan meros ololmaydi. Bu ongli ravishda qilingan, chunki sinfda aktor izolyatsiyasi mexanizmi yo'q va ikki modelni aralashtirish noaniq xatti-harakatga olib keladi.

actor SavingsAccount: BankAccount {
    func applyInterest(rate: Double) {
        let interest = balance * rate
        balance += interest
    }
}

Actor metodlarining asinxron chaqiruvlari

Asinxron chaqiruvlar — tashqi koddan aktor bilan o'zaro aloqa mexanizmidir. Aktor o'z holatini izolyatsiya qilgani uchun, uning a'zolariga tashqaridan har bir kirish await talab qiladi. Bu Swift-ga chaqiruvchi kod ipni bloklamasligini va aktor boshqa so'rovlarni qayta ishlashi mumkinligini kafolatlash imkonini beradi.

Global va lokal aktorlar

E'lon qilingan aktor turlaridan tashqari, Swift global aktorlarni qo'llab-quvvatlaydi — @MainActor atributi, u sinflar, xususiyatlar yoki metodlarni asosiy ipda bajariladigan deb belgilaydi. Bu ayniqsa UIKit va SwiftUI bilan ishlashda foydalidir.

@MainActor
class ViewModel: ObservableObject {
    @Published var title: String = ""
    
    func updateTitle() {
        // Ushbu kod asosiy ipda bajarilishi kafolatlangan
        title = "New Title"
    }
}

@MainActor dan foydalanish DispatchQueue.main.async ni qo'lda chaqirish zaruratini yo'q qiladi, bu kodni toza va xavfsizroq qiladi. Kompilyator asosiy ipga o'tishning to'g'ri amalga oshirilishini tekshiradi.

Nonisolated va actor-isolated kontekstlar

Nonisolated — aktorning metodi yoki hisoblangan xususiyatini izolyatsiyalanmagan deb belgilash imkonini beruvchi kalit so'zdir. Bunday a'zolar aktorning izolyatsiya qilingan holatiga kirish huquqiga ega emas, lekin aktordan tashqarida await-siz chaqirilishi mumkin.

Nonisolated funksiyalar

Nonisolated metodlar aktorning o'zgaruvchan holatiga bog'liq bo'lmagan hisob-kitoblar uchun foydalidir. Masalan, formatBalance metodi to'g'ridan-to'g'ri balance-ga murojaat qilmaydi, faqat uzatilgan qiymatni formatlaydi — bunday metodni xavfsiz nonisolated qilish mumkin.

actor BankAccount {
    private var balance: Double = 0
    
    nonisolated func formatBalance(amount: Double) -> String {
        return "$\(amount)"
    }
}

Nonisolated a'zolar sinxron bajariladi va await talab qilmaydi. Biroq ular to'g'ridan-to'g'ri aktorning izolyatsiya qilingan xususiyatlarini o'qiy olmaydi. Agar nonisolated metodga aktordan qiymat kerak bo'lsa, uni parametr sifatida uzatish kerak.

Reentrancy va qayta kirish

Reentrancy — asinxron chaqiruvni kutish vaqtida aktorga qayta kirish imkonini beruvchi mexanizmdir. Reentrancy bo'lmasa, aktorning bir metodi ikkinchisini kutayotgan bo'lsa, o'z navbatida ikkinchisi birinchisini kutsa, aktor abadiy bloklanishi mumkin.

Reentrancy qanday ishlaydi

Aktor ichidagi kod await ni bajarganida, aktor joriy vazifani to'xtatib qo'yadi va navbatga qo'yilgan boshqasini qayta ishlashi mumkin. await tugagandan so'ng, vazifa davom ettiriladi. Bu deadlocklarning oldini oladi, ammo ehtiyotkorlikni talab qiladi: await nuqtalari orasida aktorning holati o'zgarishi mumkin.

actor DataProcessor {
    var cache: [Int: String] = [:]
    
    func process(id: Int) async -> String {
        if let cached = cache[id] {
            return cached
        }
        // await — qayta kirish nuqtasi
        let result = await fetchData(id: id)
        // await dan keyin kesh o'zgargan bo'lishi mumkin — qayta tekshiring
        cache[id] = result
        return result
    }
}

Ishlab chiquvchilar reentrancy-ni hisobga olishlari va await nuqtalaridan keyin aktor holatini tekshirishlari kerak. Odatiy xato — aktor izolyatsiyasi asinxron pauzalar orqali saqlanadi deb taxmin qilishdir. Amalda, await va keyingi operator o'rtasida holat kutilganidan farq qilishi mumkin.