0Pricing
Swift Academy · Aula

Atores e isolamento de dados, nonisolated

Aprenda o isolamento de atores: o estado é protegido por um actor , o acesso entre atores exige await e os membros nonisolated ignoram o isolamento quando são puros ou estáticos.

Atores e isolamento de dados, nonisolated é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 3. 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 3 aulas no total.

O que os atores oferecem

Um ator protege seu estado mutável. Somente uma tarefa acessa o estado isolado por vez; os chamadores externos devem usar await nos métodos do ator.

  • Isolamento = nenhuma condição de corrida de dados
  • Chamadas entre atores são assíncronas
  • nonisolated para membros puros ou estáticos

Noções básicas de atores

Dentro do ator, o acesso é direto. De fora, você deve usar await tanto para ler quanto para escrever no estado isolado.

actor Counter {
    private var value: Int = 0   // isolated state

    func increment() { value += 1 }      // isolated method (async to outsiders)
    func get() -> Int { value }          // read isolated state
}

let c = Counter()
Task {
    await c.increment()
    print(await c.get())  // 1
}

Garantia de serialização

Mesmo que várias tarefas chamem o ator simultaneamente, o ator serializa o acesso ao seu estado, impedindo condições de corrida.

actor BankAccount {
    private var balance: Int = 0
    func deposit(_ amount: Int) { balance += amount }
    func withdraw(_ amount: Int) -> Bool {
        if balance >= amount { balance -= amount; return true }
        return false
    }
    func current() -> Int { balance }
}

let acc = BankAccount()
Task {
    async let a = acc.deposit(50)
    async let b = acc.withdraw(20)
    _ = await (a, b)                 // operations are serialized inside the actor
    print(await acc.current())       // deterministic balance
}

APIs nonisolated

Marque como nonisolated os membros puros ou estáticos para que os chamadores não precisem usar await. Eles não devem acessar o estado isolado.

actor Clock {
    private var ticks: Int = 0
    func tick() { ticks += 1 }
    func read() -> Int { ticks }

    // Nonisolated: safe without awaiting (pure computation / constant)
    nonisolated static let format = "HH:mm:ss"

    nonisolated func describeFormat() -> String {
        // Cannot touch isolated state here; this is pure
        return "Format: " + Self.format
    }
}

let cl = Clock()
Task {
    await cl.tick()
    print(await cl.read())           // 1
    // Nonisolated members don't require await:
    print(Clock.format)              // "HH:mm:ss"
    print(cl.describeFormat())       // sync call
}

Atenção à reentrância

Os atores podem ser reentrantes: depois de um await dentro de um método do ator, outras mensagens podem ser executadas. Mantenha os invariantes válidos entre os pontos de await.

actor Logger {
    private var lines: [String] = []
    func log(_ s: String) async {
        lines.append(s)
        // Simulate an await point; actor may process other messages here (reentrant)
        try? await Task.sleep(nanoseconds: 10_000_000)
        lines.append("done")
    }
    func snapshot() -> [String] { lines }
}

let logger = Logger()
Task {
    async let a = logger.log("A")
    async let b = logger.log("B")
    _ = await (a, b)
    print(await logger.snapshot())   // order shows possible interleaving
}

Boas práticas

Diretrizes:

  • Disponibilize métodos assíncronos pequenos; evite seções críticas longas.
  • Use nonisolated para constantes e auxiliares puros.
  • Não armazene estado mutável compartilhado não-Sendable fora dos atores (você aprenderá Sendable a seguir).

Requisito de isolamento do ator

Verificação rápida: como ler ou escrever o estado de um ator a partir de fora?

Recapitulação

Recapitulação: os atores isolam o estado mutável; o acesso externo exige await. Use nonisolated para membros puros ou estáticos e projete métodos assíncronos curtos para manter a segurança durante a reentrância.

Perguntas Frequentes

A aula “Atores e isolamento de dados, nonisolated” é grátis?

Sim — o texto completo de “Atores e isolamento de dados, 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 3 aulas no total.

O que vou aprender em “Atores e isolamento de dados, nonisolated”?

Aprenda o isolamento de atores: o estado é protegido por um actor , o acesso entre atores exige await e os membros nonisolated ignoram o isolamento quando são puros ou estáticos. 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 2 de 3.

Quanto tempo leva a aula “Atores e isolamento de dados, 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

  1. TaskGroup para paralelismo
  2. Atores e isolamento de dados, nonisolated
  3. Sendable e verificação de segurança entre threads
← Voltar para Swift Academy