Como funciona a concorrência do Swift com async/await, Task, actors e @MainActor?

Question

IT Interview Practice · Accepted Answer

A concorrência do Swift permite escrever código assíncrono que se lê como código síncrono usando `async`/`await`, enquanto o compilador impõe segurança contra data races. `Task` inicia trabalho concorrente, **actors** protegem estado mutável, e `@MainActor` garante que o código de UI execute na thread principal.

## Como funciona

`await` marca um **ponto de suspensão**: a função pode pausar ali, liberando a thread para outro trabalho, e retomar quando o valor aguardado estiver pronto — sem callbacks, sem bloqueio de thread.

```swift
func loadProfile() async throws -> Profile {
    let user  = try await fetchUser()       // suspende, thread reutilizada
    let posts = try await fetchPosts(user)  // executa após user resolver
    return Profile(user: user, posts: posts)
}

// Inicia trabalho assíncrono a partir de um contexto síncrono
Task {
    let profile = try await loadProfile()
    await MainActor.run { render(profile) } // atualização de UI na thread principal
}
```

## Actors e @MainActor

Um **actor** serializa o acesso ao seu estado mutável — apenas uma task o toca por vez, então sem locks e sem data races.

```swift
actor ImageCache {
    private var store: [URL: Image] = [:]
    func image(for url: URL) -> Image? { store[url] }   // isolado
    func insert(_ img: Image, for url: URL) { store[url] = img }
}

@MainActor
final class ViewModel: ObservableObject {   // todos os membros executam na thread principal
    @Published var title = ""
}
```

## Concorrência estruturada

`async let` e `TaskGroup` executam filhos em paralelo e os aguardam juntos; cancelar o pai cancela os filhos.

```swift
async let a = fetchA()      // ambos começam imediatamente, em paralelo
async let b = fetchB()
let (x, y) = try await (a, b)
```

## Armadilhas

- Esquecer `@MainActor` em atualizações de UI causa avisos de "Publishing changes from background thread".
- `Task { }` herda o contexto do actor; `Task.detached` não — use-o com moderação.

## Por que isso importa

async/await substituiu completion handlers profundamente aninhados ("callback hell") e o compilador agora detecta data races em tempo de compilação. Entrevistadores verificam se você entende pontos de suspensão, isolamento de actor e `@MainActor` — o modelo que torna a concorrência moderna no iOS ao mesmo tempo legível e segura.

Como funciona

Actors e @MainActor

Concorrência estruturada

Armadilhas

Por que isso importa

Perguntas relacionadas