Entendendo @MainActor em Swift: quando e como usá -lo

O que são atores em Swift? Os atores são um recurso de concorrência fundamental introduzido no Swift 5.5 que fornece uma maneira segura de gerenciar o estado mutável em programas simultâneos. Um ator é um tipo de referência que protege seu estado mutável, garantindo que apenas uma tarefa possa acessar suas propriedades e métodos por vez. Pense em um ator como um invólucro protetor em torno de dados que lida automaticamente com a sincronização. Quando várias tarefas tentam acessar um ator simultaneamente, o SWIFT garante que eles esperem na fila, impedindo as corridas de dados e falhas que geralmente ocorrem em programação com vários threads. Ator BankAccount {Private var Balance: Double = 0.0 Func Deposit (_ Montante: Double) {Balance += valor} func GetBalance () -> Double {Return Balank}} Digite o modo de tela cheia de tela cheia o que é o @MainActor? @MainActor é um ator especial que representa o encadeamento principal de um aplicativo. É um ator global que garante que o código seja executado na fila de despacho principal, essencial para as atualizações da interface do usuário e outras operações somente para o main-thread. O @MainActor serve como o substituto moderno de Swift para despachar manualmente para a fila principal usando DispatchQueue.main.async. Ele fornece uma sintaxe de segurança e limpeza em tempo de compilação para operações de thread principal. O principal benefício do @MainActor é que ele move as preocupações de segurança do fio do tempo de execução para o tempo de compilação. Em vez de se lembrar de envolver o código da interface do usuário em chamadas de expedição, o compilador aplica a execução do tiro principal automaticamente. Quando usar as atualizações da UI @MainActor e visualizar modificações O caso de uso mais importante para @MainActor está garantindo que as atualizações da interface do usuário ocorram no thread principal. Todas as estruturas da interface do usuário exigem modificações de interface no encadeamento principal para evitar falhas e garantir a experiência suave do usuário. Os controladores de visualização e as classes da interface do usuário aplicam @MainActor a classes inteiras que lidam principalmente com operações de interface do usuário, como controladores de visualização, gerentes de interface do usuário e modelos de exibição Swiftui. Delegar métodos e retornos de chamada da interface do usuário ao implementar métodos de delegados ou manipuladores de conclusão que atualizam a interface do usuário, @MainActor garante que eles sejam executados no thread correto. Animações de UI de animação e efeitos visuais, transições e efeitos visuais devem ser executados no thread principal para funcionar corretamente. Como usar o aplicativo de nível de classe @MainActor Quando aplicado a uma classe, todas as propriedades e métodos se tornam ligados ao ator principal, garantindo que tudo funcione no tópico principal: @MainActor class WeatherviewModel: obsertableObject {@published var temperature: “-” @published Condition: string = “Unknown” Chamada de rede acontece no thread de fundo, deixe o clima data = aguardar weatherService.FetchCurrentWeather () // Atualizações de interface do usuário acontecem automaticamente na temperatura da linha principal = “\ (WeatherData.temperature) °” Condição = Modo de WeatherData.Condition Isloading = False} FuShWeather {) Ext -sclatiTit.Condition Isloading = False} RefreshWeather {) {Task {AwaT LOADWATHEATHELATH () Toda a classe WeatherViewModel está marcada com @MainActor. Isso significa todas as propriedades (temperatura, condição, iscações) e métodos (loadweather (), refreshweather ()) são executados automaticamente no encadeamento principal. Quando o loadweather () atualizar as propriedades @published, o Swiftui receberá essas alterações no thread principal, garantindo atualizações suaves da interface do usuário. Aplicação no nível do método para classes que misturam UI e trabalho de fundo, métodos específicos podem ser marcados para executar no ator principal: classe Datamanager {private var cache: [String: Any] = [:]

// Trabalho em segundo plano – não está no thread principal func fetchUserdata (userID: string) assync -> userData {let userData = wait networkService.getUserdata (userID: userID) cache[userId] = userData return userData } // UI update – must be on main thread @MainActor func updateUserInterface(with userData: UserData) { NotificationCenter.default.post( name: .userDataUpdated, object: userData ) } } Enter fullscreen mode Exit fullscreen mode Property-Level Application Individual properties can be marked with @MainActor for more Controle granular: classe appSettings {@MainActor var CurrentTheme: tema = .Llight var apitimeout: timeInterval = 30.0 // Propriedade de plano de fundo var RETRYCOUNT: INT = 3 // Propriedade de fundo @MainActor FuncTETETETHEME (_ NEWTHEME: tema) {CurrentThemEr = Newtheme //Ist Updetheme on Main Notification On Main Notification (_ Notheme: tema) {CurrentThemEr = Newtheme //Ist no notificação no MAIN Notification On MainstEng. Objeto: CurrentTheme)} FunctateTeMeFrombackground (_ Newtheme: tema) Async {// deve usar aguardar ao chamar @MainActor Método de fundo Aguarda UpdateTheme (NewStheMe)}} Digite o Modo Full -Screen EXIT ACESSO ACESSO Neste exemplo, apenas o ponto atual é marcado com o tema @Main, o tema, o tema -themear, o Modo FullSuring Acepsing Aceping Ownst. Os principais benefícios do @MainActor Compile Time Safety @MainActor fornecem o tempo de compilação garante que o código da interface do usuário é executado no thread principal, impedindo falhas de tempo de execução que ocorrem quando a interface do usuário é acessada a partir de threads de fundo. O código mais limpo elimina a necessidade de expedição manual.main.async Chamadas, tornando o código mais legível e menos propenso a erros. A integração perfeita com async/aguarda funciona naturalmente com os modernos recursos de simultaneidade de Swift, permitindo transições suaves entre o trabalho de fundo e o trabalho principal. Compatibilidade Swiftui essencial para aplicativos SwiftUI, onde as atualizações de exibição devem acontecer no thread principal para acionar as atualizações adequadas da interface do usuário. As práticas recomendadas se aplicam no nível certo, use o nível de método @MainActor para métodos de atualização de interface do usuário específicos em classes de uso misto, mantenha a reserva de luz principal principal Reserva de luz @MainActor Código para atualizações da interface do usuário e operações de luz. Execute cálculos pesados em threads de fundo antes de atualizar a interface do usuário. Entenda o contexto assíncrono Lembre -se de que chamar o código @MainActor dos contextos de fundo requer aguardar e cria um ponto de suspensão em que a função pode ser pausada ao alternar para o thread principal.

Fonte