@MainActor — какво е, приложение и особености в асинхронен код Swift

Какво е @MainActor?

@MainActor е глобален актьор (global actor) в Swift, който съчетава свойствата на актьорите с гаранция за изпълнение на главната нишка на приложението. То е част от системата за конкурентност на Swift, представен в Swift 5.5 заедно с async/await и структурирана конкурентност. Анотацията позволява на разработчика да не мисли за ръчно преключване на нишките и намалява броя на UI грешките.

Определение и място в Swift Concurrency

Актьорът в Swift е референтен тип, който изолира състоянието си и гарантира, че само една нишка може да го променя. @MainActor е специален глобален актьор, чийто изпълнител е главната нишка. Всяк код, маркиран с @MainActor, се изпълнява на главната нишка — дори ако е бил извикан от задача на заден план.

Преди появата на @MainActor, разработчиците ръчно преключваха към главната нишка чрез DispatchQueue.main.async. Това беше източник на чести грешки: разработчиците забравяха да преключат, което водеше до крашове поради актуализиране на UI на неглавната нишка. @MainActor решава този проблем на ниво система от типове.

Причини за създаване

Източникът на повечето грешки в iOS приложения е UI-несигурността — актуализиране на интерфейса от задна нишка. Apple вгради @MainActor в Swift Concurrency, за да направи преключването към главната нишка автоматично и проверяемо от компилатора, елиминирайки цял клас от runtime грешки.

Как работи @MainActor?

Принципът на действие на @MainActor се базира на изпълнителната система на Swift Concurrency. Когато една нишка извика функция, маркирана с @MainActor, планировшикът го спира на текущия изпълнител и го подновява на главната нишка. Компилаторът проследява границите на извикването и гарантира сигурност.

Изпълнител на главната нишка

За изпълнението на @MainActor отговаря MainActor.shared — изпълнителът, свързан с главната нишка на приложението. Когато асинхронна функция е маркирана с @MainActor, тя винаги се подновява на този изпълнител, независимо от това на коя нишка е стартирала първоначалната задача.

import SwiftUI

class ViewModel: ObservableObject {
    @Published var items: [String] = []

    @MainActor
    func loadData() async {
        let result = await fetchRemoteData()
        items = result  // безопасно, MainActor гарантира главната нишка
    }
}

Наследяване на контекста на актьора

Ако функция е маркирана с @MainActor и извика друга асинхронна функция, по подразбиране тя наслява контекста на актьора. Това означава, че всички вложени извиквания се изпълняват също на главната нишка, освен ако не е посочено друго. Компилаторът проследява това и дава грешка при опит за предаване на несъвместимо затваране.

@MainActor vs DispatchQueue.main

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

Сигурност на ниво типове

@MainActor е проверка на ниво компилатор. Ако опитате да извикате @MainActor функция от несигурно контекст, компилаторът ще даде предупреждение или грешка. DispatchQueue.main.async е runtime извикване: кодът ще се компилира, но може да се крашне при работа при опит за актуализиране на UI от задна нишка.

Производителност и излишност

DispatchQueue.main.async добавя блок в опашката, който може да се изпълни с закъснение. @MainActor с async/await извършва пряко преключване на изпълнителя, без да създава допълнителни затварания. Това намалява натоварането и прави кода по-предсказуем по отношение на времето за изпълнение.

// Стар подход
DispatchQueue.main.async {
    self.updateUI()
}

// Нов подход с @MainActor
@MainActor
func updateUI() {
    // се изпълнява на главната нишка
    self.label.text = "Актуализирано"
}

Използване на @MainActor в iOS проекти

В реални iOS проекти, @MainActor се прилага в ViewModel слоевете, SwiftUI изгледи и UIKit контролерите. Анотацията може да се приложи както на отделни методи, така и на целия тип.

Анотация на класа или структурата

Като маркирате клас с @MainActor, гарантирате, че всичките му методи и свойства са достъпни само на главната нишка. Това е особено удобно за SwiftUI изгледи и ObservableObject класове: просто добавяте @MainActor пред class и всички @Published свойства се актуализират безопасно.

@MainActor
final class UserListViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false

    func fetchUsers() async {
        isLoading = true
        users = await api.getUsers()
        isLoading = false
    }
}

Обвиване на legacy код

При работа със стар UIKit код, където преключването на нишките е било ръчно, може да се използва MainActor.run за явно преключване. Това е удобно за постепен преход към Swift Concurrency, без да се препишва цялата кодова база.

await MainActor.run {
    self.tableView.reloadData()
}

Ограничения на @MainActor

Въпреки всички предимства, @MainActor има редица ограничения, които трябва да се вземат предвид при проектирането на архитектурата на приложението. Разбирането на границите на приложимост помага да се избегне неправилната употреба.

Производителност при интензивна употреба

Ако цялата верига от извиквания е маркирана с @MainActor, всяка тежка работа ще се изпълнява на главната нишка, причинявайки замразване на UI. Препоръчва се да маркирате с @MainActor само UI слоя, а бизнес логиката и мрежовите заявки да останат в актьорите на заден план или глобалния изпълнител.

Несъвместимост с някои API

Старите API, базиращи се на callback (например, URLSession без async/await), не поддържат контекста на актьора. За интеграция се изисква обвиване с CheckedContinuation. Също така, @MainActor не е съвместим с performSelector, target-action и други неасинхронни модели на UIKit.

Многонишково отладване

При отладването на приложения с @MainActor е по-трудно да се възпроизведат състояния на надпреварване, защото компилаторът предотвратява много от тях в фазата на изграждане, а не при работа. Това обаче може да създаде фалшиво усещане за сигурност: неправилната работа с общи mutable обекти (например, NSCache или общи глобални променливи) е все още възможна, ако не са маркирани с @MainActor и се използват без явна синхронизация.

Тестване на @MainActor

@MainActor значително опростява тестването на UI логиката, тъй като елиминира необходимостта от ръчно преключване на нишките в тестовете. Съществуват обаче характеристики, които трябва да се вземат предвид при писането на единични тестове и UI тестове.

Единични тестове с MainActor

В XCTest, изпълнителната среда автоматично настроява изпълнителя на главната нишка. Когато тестовият метод се изпълнява на главната нишка, извикването на @MainActor функции не изисква допълнителна конфигурация — те се изпълняват в същия контекст. За тестване на сценарии на заден план, използвайте MainActor.run внутрено в Task с явно посочване на приоритет и изпълнител, като отделно проверявате, че кодът работи правилно при извикване от заден план.

Един от обичайните подходи е тестването на ViewModel с @MainActor, където се проверява, че @Published свойствата се актуализират правилно след асинхронни операции. Благодарение на наследяването на контекста на актьора, извикването await внутрено в теста гарантира изпълнение на главната нишка без допълнителни DispatchQueue гаранции и явно преключване на контекста, което опростява писането на тестовете.

Проверка на изолацията при рефакториране

При рефакториране на съществуващ код към Swift Concurrency, проверявайте изолацията @MainActor чрез компилатора: всяко извикване на синхронни методи без @MainActor от @MainActor контекст се маркира като грешка. Това свойство се използва за постепен преход на проекта към async/await: маркирате ViewModel слоя като @MainActor и компилаторът подсветлява всички несигурни извиквания, които трябва да се преместят в актьорите на заден план.

Mockване и контекст на актьора

При създаването на mockове за @MainActor зависимости, използвайте протоколи с async методи, които декларират асинхронни функции с възвращаеми типове. Това позволява замяна на мрежови услуги, бази от данни и други външни зависимости, без да се нарушава актьорната изолация. Компилаторът ще провери дали mockът отговаря на всички изисквания за изолация, предотвратявайки случаен достъп до @MainActor код от тестови нишки на заден план.

Изчакване на асинхронни операции

При синхронно тестване на @MainActor код, използвайте XCTestExpectation за изчакване на завършването на асинхронните операции. Поставете очакването в теста и изпълнете fulfillment внутрено в затварането, което се изпълнява на главната нишка. Ако тестът висне безкрайно — вероятно извикването на главната нишка не се случва и трябва да се провери актьорната изолация. За отладване на контекста на изпълнение, полезно е да добавите проверка Thread.isMainThread внутрено в тестовия код.