Actor — какво е, изолация на данни и конкурентност

Какво е Actor в Swift?

Actor — е референтен тип, подобен на клас, но с автоматична защита срещу състезание на данни. Беше представен в Swift 5.5 като част от система за конкурентност заедно с async/await и Task. Actor гарантира, че променливото му състояние никога няма да бъде едновременно четено или записвано от различни нишки без изрична синхронизация.

Синтаксис на деклариране на Actor

За деклариране на actor се използва ключовата дума actor, следвана от фигурни скоби с неговите членове. Синтактически, actor напомня клас, но поведението му е радикално различно.

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

Компилаторът автоматично изолира всички свойства и методи на actor така, че те са достъпни само в контекста на actor. Опит за достъп до balance отвън actor ще предизвика грешка на компилатора, ако призовът не е маркиран като async.

Как работи изолацията на данни в Actor

Изолация на данни — е ключовата концепция на actor. Actor гарантира взаимно изключващ достъп до състоянието си чрез механизма на изпълнителя на actor (actor executor). Всеки actor има собствен изпълнител, който обработва всички достъпи до неговите изолирани членове последователно.

Принцип на действие на изолацията

Когато код извън actor вика неговия метод, призовът се поставя в опашката на изпълнителя на actor. Actor изпълнява само една задача едновременно, което гарантира липсата на състезания. Ако две нишки едновременно викат deposit, вторият призов чака завършването на първия.

let account = BankAccount(initialBalance: 1000.0)
// Асинхронен призов — изисква се отвън actor
await account.deposit(amount: 500.0)
let currentBalance = await account.getBalance()

Всеки призов на метод на actor изисква await, защото actor може да е зает с друга задача. Това не е грешка, а съзнателен дизайн за предотвратяване на състезания. Swift имплицитно прави getter и setter на свойствата на actor async, така че четенето на свойство също изисква await.

Основни разлики между Actor и клас

Actor и класът са референтни типове, но поведението им в многонишкова среда се различава радикално. Класът не осигурява никаква автоматична защита срещу състезания, докато actor го вгражда на ниво компилатор чрез системата от типове.

Наследяване на Actor

Actor може да наследява само от друг actor и не може да наследява от клас. Това е направено съзнателно, тъй като класът няма механизъм за изолация на actor и смесването на двата модела би довело до недефинирано поведение.

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

Асинхронни призови на методите на Actor

Асинхронни призови — са механизъм за взаимодействие с actor от външен код. Тъй като actor изолира състоянието си, всяка промяна на неговите членове отвън изисква await. Това позволява на Swift да гарантира, че викащият код не блокира нишката и че actor може да обработва други заявки.

Глобални и локални actor

Освен декларираните типове actor, Swift поддържа глобални actor — атрибута @MainActor, който маркира класове, свойства или методи като изпълнявани на главната нишка. Това е особено полезно при работа с UIKit и SwiftUI.

@MainActor
class ViewModel: ObservableObject {
    @Published var title: String = ""
    
    func updateTitle() {
        // Този код гарантирано се изпълнява на главната нишка
        title = "New Title"
    }
}

Използването на @MainActor премахва необходимостта от ръчно викане на DispatchQueue.main.async, което прави кода по-чист и по-сигурен. Компилаторът проверява дали преключването към главната нишка се извършва правилно.

Nonisolated и actor-isolated контекстове

Nonisolated — е ключова дума, която позволява да маркирате метод или изчисляемо свойство на actor като неизолирано. Такива членове нямат достъп до изолираното състояние на actor, но могат да бъдат викани без await отвън actor.

Nonisolated функции

Nonisolated методите са полезни за изчисления, които не зависят от променливото състояние на actor. Например, методът formatBalance няма пряк достъп до balance, а само форматира подадената стойност — такъв метод може безопасно да бъде направен nonisolated.

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

Nonisolated членовете се изпълняват синхронно и не изискват await. Въпреки това, те не могат директно да четат изолираните свойства на actor. Ако nonisolated метод се нуждае от стойност от actor, тя трябва да бъде предадена като параметър.

Reentrancy и повторно вхождане

Reentrancy — е механизъм, който позволява повторно вхождане в actor по време на чакане за асинхронен призов. Без reentrancy, actor би могъл да се блокира завинаги, ако един негов метод чака друг, който от своя страна чака първия.

Как работи reentrancy

Когато код в актьора изпълнява await, актьорът спира текущата задача и може да обработи друга, поставена в опашката. След завършване на await, задачата се подновява. Това предотвратява deadlock, но изисква внимание: състоянието на actor между точките на await може да се промени.

actor DataProcessor {
    var cache: [Int: String] = [:]
    
    func process(id: Int) async -> String {
        if let cached = cache[id] {
            return cached
        }
        // await — точка на повторно вхождане
        let result = await fetchData(id: id)
        // Кешът може да се е променил след await — проверете отново
        cache[id] = result
        return result
    }
}

Разработчиците трябва да вземат предвид reentrancy и да проверяват състоянието на actor след точките на await. Типична грешка е предположението, че изолацията на actor се запазва през асинхронни паузи. На практика, между await и следващата инструкция, състоянието може да се различава от очакваното.