Concorrência em Swift: threads, goroutines e async/await — como não enlouquecer

Introdução: por que seu iPhone não trava enquanto você rola o feed?

Você já se perguntou por que os aplicativos iOS modernos não travam, mesmo quando carregam dezenas de imagens, processam toques e gravam dados no banco de dados ao mesmo tempo? A resposta é simples — concorrência. No mundo Swift (e não só) este é um dos tópicos mais quentes. E se você programa em Swift, mas ainda se confunde com threads, goroutines e o moderno async/await — bem-vindo ao clube. Hoje vamos organizar tudo para que seu código voe, não rasteje.

Neste artigo, não vamos apenas listar definições secas. Vamos ver exemplos reais, comparar abordagens e responder à pergunta principal: o que escolher para seu projeto — o bom e velho GCD ou o novo Swift Concurrency?

Threads: a base que sustenta tudo

Vamos começar pelo básico. Thread é a menor unidade de processamento que o sistema operacional pode executar. Imagine uma esteira: uma thread é uma linha pela qual as tarefas se movem. Se você tem um núcleo de processador, as threads serão executadas uma após a outra, mas alternando muito rapidamente, criando a ilusão de paralelismo. Em processadores multi-core, as threads podem ser executadas realmente em paralelo.

Em Swift, por muito tempo a principal ferramenta para trabalhar com threads foi o Grand Central Dispatch (GCD). Você simplesmente criava uma fila e enviava uma closure para ela:

DispatchQueue.global(qos: .background).async {\n    // Trabalho pesado em segundo plano\n    let result = heavyComputation()\n    DispatchQueue.main.async {\n        // Atualização da UI na thread principal\n        self.label.text = result\n    }\n}

Simples, certo? Mas o GCD tem suas nuances:

\n
• Você é responsável por retornar à thread principal (fácil de esquecer e causar um crash).
\n
• Não há suporte nativo para cancelamento de tarefas (é preciso escrever flags manualmente).
\n
• É difícil lidar com cadeias de operações dependentes sem aninhar closures (o chamado "callback hell").
\n

Ainda assim, o GCD continua vivo e é usado em projetos legados. Mas o Swift moderno oferece algo muito mais elegante.

Goroutines em Swift? Não, isso não é Go

Quando se fala em goroutines, geralmente lembramos de Go. Em Swift não há um análogo direto de goroutines, mas existem tarefas leves (tasks) que se comportam de forma muito semelhante. Elas não estão vinculadas a uma thread específica — o próprio sistema decide em qual thread executar a tarefa e pode alterná-las entre threads sem criar novas a cada chamada.

Ao contrário das threads, que "pesam" cerca de 8 KB de pilha cada, as tarefas do Swift Concurrency praticamente não pesam nada. Você pode executar milhares de tarefas sem risco de estourar a memória. Essa é a tal "concorrência sem dor".

Veja como fica:

Task {\n    let image = await downloadImage(from: url)\n    await MainActor.run {\n        self.imageView.image = image\n    }\n}

Percebeu? Nada de DispatchQueue.main.async. Apenas await MainActor.run. Limpo, claro, seguro.

async/await: a revolução que aconteceu

Com o lançamento do Swift 5.5, veio o suporte nativo a async/await. Isso não é apenas açúcar sintático — é uma mudança de paradigma. Agora você pode escrever código assíncrono como se fosse síncrono, mas sem bloquear a thread.

Declarar uma função assíncrona é simples:

func fetchUserData() async throws -> User {\n    let url = URL(string: "https://api.example.com/user")!\n    let (data, _) = try await URLSession.shared.data(from: url)\n    return try JSONDecoder().decode(User.self, from: data)\n}

E chamá-la é ainda mais simples:

Task {\n    do {\n        let user = try await fetchUserData()\n        print("User nam