0Pricing
Swift Academy · Aula

Atores: proteção do estado mutável compartilhado

Use actor para serializar o acesso e evitar condições de corrida nos dados em tempo de compilação.

Atores: proteção do estado mutável compartilhado é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Boas-vindas

Os atores do Swift protegem o estado mutável compartilhado contra acessos simultâneos usando o *isolamento de ator*. Eles oferecem concorrência segura sem bloqueios manuais.

Definindo um ator

```swift actor Counter { var count = 0 func increment() { count += 1 } func value() -> Int { count } } ```

Acessando o estado de um ator

```swift let counter = Counter() await counter.increment() // await required for external access let v = await counter.value() ``` Todas as chamadas entre atores são assíncronas — elas aguardam a vez do ator.

Isolamento de dados

```swift actor BankAccount { private var balance: Double = 0 func deposit(_ amount: Double) { balance += amount } func withdraw(_ amount: Double) throws { guard amount <= balance else { throw BankError.insufficient } balance -= amount } } ```

nonisolated

```swift actor Config { nonisolated let appName: String = "CoddyKit" // safe to access without await var settings: [String:String] = [:] } let name = Config().appName // no await needed ```

@MainActor

```swift @MainActor class ViewController { var label = UILabel() func updateText(_ text: String) { label.text = text // guaranteed on main thread } } ``` `@MainActor` é um ator especial que é executado na linha de execução principal.

Requisito de Sendable

Os tipos passados entre limites de atores devem estar em conformidade com `Sendable`: ```swift struct Message: Sendable { var text: String; var timestamp: Date } await actor.receive(message) // safe — Message is Sendable ```

Ator vs. classe

| Recurso | Ator | Classe | |---|---|---| | Seguro para concorrência | ✓ | ✗ | | Tipo de referência | ✓ | ✓ | | Herança | ✗ | ✓ | | Acesso assíncrono | ✓ | — |

Atores não podem entrar em bloqueio mútuo

Ao contrário dos bloqueios, os atores não podem entrar em bloqueio mútuo — mas podem causar *reentrância de ator* quando um ator aguarda outro e uma segunda chamada chega nesse intervalo.

Atores globais

```swift @globalActor struct DatabaseActor { static let shared = Actor() actor Actor {} } @DatabaseActor func save() { ... } ```

Verificação rápida

Por que o acesso externo às propriedades de um ator precisa usar `await`?

Recapitulação

Principais conclusões: • Os atores protegem o estado mutável — uma tarefa é executada por vez • O acesso externo exige `await` • `nonisolated` para membros seguros e não isolados • `@MainActor` — é executado na linha de execução principal; use-o para a interface do usuário • Os tipos que atravessam limites de atores devem ser `Sendable` Curso concluído! A seguir: Genéricos avançados.

Perguntas Frequentes

A aula “Atores: proteção do estado mutável compartilhado” é grátis?

Sim — o texto completo de “Atores: proteção do estado mutável compartilhado” é 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 “Atores: proteção do estado mutável compartilhado”?

Use actor para serializar o acesso e evitar condições de corrida nos dados em tempo de compilação. 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 4 de 4.

Quanto tempo leva a aula “Atores: proteção do estado mutável compartilhado”?

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

  1. Sintaxe async/await e chamada de funções assíncronas
  2. Task e cancelamento de Task
  3. async let e tarefas filhas concorrentes
  4. Atores: proteção do estado mutável compartilhado
← Voltar para Swift Academy