Isolamento de Actors e nonisolated
Raciocine sobre os limites de isolamento.
Isolamento de Actors e nonisolated é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.
O que é o Isolamento de Atores?
O isolamento de atores significa que o estado mutável de um ator só pode ser acessado por código executado nesse ator.
O ambiente de execução serializa o acesso, para que duas tarefas nunca modifiquem o estado simultaneamente, eliminando corridas de dados.
actor Counter {
private var value = 0
func increment() { value += 1 }
}Chamando um Ator
Fora do ator, acessar membros isolados é assíncrono. Você precisa de await, pois a chamada pode ser suspensa até que o ator esteja disponível.
let counter = Counter()
func useCounter() async {
await counter.increment()
}Dentro do Ator: Síncrono
Dentro dos próprios métodos do ator, você já está isolado, portanto acessa o estado de forma síncrona — não é necessário usar await para self.
actor Counter {
private var value = 0
func incrementTwice() {
value += 1 // synchronous: already isolated
value += 1
}
}Membros não isolados
Marque um membro como nonisolated quando ele não acessar o estado mutável. Esses membros são executados de forma síncrona a partir de qualquer lugar, sem await.
Isso é ideal para valores computados criados apenas a partir de dados imutáveis.
actor User {
let id: Int
var sessionCount = 0
init(id: Int) { self.id = id }
nonisolated var label: String { "User #\(id)" }
}Por que nonisolated é Seguro
Um membro nonisolated só pode ler estado imutável (let) ou estado Sendable.
O compilador rejeita qualquer tentativa de acessar estado mutável isolado a partir de um contexto não isolado.
actor User {
let id: Int
var sessionCount = 0
init(id: Int) { self.id = id }
// Error: cannot read mutable sessionCount here
// nonisolated var bad: Int { sessionCount }
}nonisolated e Protocolos
nonisolated é essencial quando um ator está em conformidade com um protocolo síncrono. O método do protocolo não pode ser assíncrono, portanto precisa evitar o estado isolado.
actor Item: CustomStringConvertible {
let name: String
init(name: String) { self.name = name }
nonisolated var description: String { "Item: \(name)" }
}O MainActor
@MainActor é um ator global que isola o código na linha de execução principal. As atualizações da interface do usuário devem ficar aqui.
Anote tipos, métodos ou propriedades para vinculá-los ao ator principal.
@MainActor
final class ViewModel {
var title = "Hello"
func refresh() { title = "Updated" }
}Alternando entre Atores
Quando você chama de um ator para outro, o ambiente de execução alterna entre executores e suspende a execução. Essa suspensão é exatamente onde await aparece.
actor Database { func load() -> Int { 42 } }
@MainActor
func show(_ db: Database) async {
let v = await db.load() // hop to db actor
print(v) // hop back to main
}Reentrância de Atores
Atores são reentrantes: quando um método aguarda, o ator pode executar outro trabalho enfileirado antes de retomar após o await.
O estado lido antes de um await pode ter mudado depois dele. Verifique novamente as suposições após os pontos de suspensão.
actor Store {
var ready = false
func prepare() async {
ready = false
await Task.yield() // other calls may run here
ready = true
}
}Parâmetros isolados
Uma função pode receber um parâmetro de ator isolated, executando seu corpo nesse ator sem ser membro dele.
func bump(on counter: isolated Counter) {
// runs isolated to counter; synchronous access
}Atores Globais para Subsistemas
Você pode definir seu próprio ator global para isolar um subsistema inteiro (por exemplo, um fluxo de renderização) em um único executor.
@globalActor
actor RenderActor {
static let shared = RenderActor()
}
@RenderActor func draw() { }Verificação Rápida: Isolamento
Teste sua compreensão do isolamento de atores.
Recapitulação: Isolamento de Atores e nonisolated
O isolamento de atores serializa o acesso ao estado mutável; chamadas entre atores são assíncronas e exigem await. Membros nonisolated optam por não participar do isolamento, mas só podem ler estado imutável ou Sendable, o que é essencial para a conformidade com protocolos síncronos.
@MainActor vincula o código à linha de execução principal, os atores são reentrantes (o estado pode mudar entre await), e atores globais isolam subsistemas inteiros. Dominar essas regras é o núcleo da concorrência segura.
Perguntas Frequentes
A aula “Isolamento de Actors e nonisolated” é grátis?
Sim — o texto completo de “Isolamento de Actors e nonisolated” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.
O que vou aprender em “Isolamento de Actors e nonisolated”?
Raciocine sobre os limites de isolamento. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Swift Academy?
Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Isolamento de Actors e nonisolated”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Swift Academy?
Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- O Problema das Corridas de Dados
- O Protocolo Sendable
- Isolamento de Actors e nonisolated
- Migração para Concorrência Estrita