Programação Assíncrona em Swift: guia completo para iniciantes

Introdução à Programação Assíncrona em Swift

Aplicativos móveis e desktop modernos precisam ser responsivos e rápidos. Ninguém gosta quando a interface trava ao carregar dados da rede ou processar um arquivo grande. É aqui que a programação assíncrona entra em ação. Em Swift, a partir da versão 5.5, surgiu um conjunto de ferramentas poderoso e intuitivo para trabalhar com assincronia — async/await, Task e Actor.

Neste guia, vamos abordar os fundamentos da programação assíncrona em Swift para iOS e macOS. Você aprenderá a escrever código assíncrono sem callbacks (callback hell), gerenciar threads corretamente e evitar condições de corrida. O material é voltado para desenvolvedores iniciantes que já conhecem os fundamentos da sintaxe do Swift.

O que é programação assíncrona e por que ela é necessária?

Imagine que seu aplicativo é um cozinheiro na cozinha. Se o cozinheiro ficar esperando a chaleira ferver e não fizer nada, o almoço vai demorar. A programação assíncrona permite que o "cozinheiro" (thread principal) coloque a chaleira e, sem esperar ela ferver, comece a cortar a salada. Quando a chaleira ferver, o cozinheiro volta para ela.

No contexto do iOS, isso significa que operações pesadas (carregar uma imagem, fazer parsing de JSON, trabalhar com banco de dados) são executadas em segundo plano, sem bloquear a thread principal, que é responsável por atualizar a interface. Se isso não for feito, o aplicativo "trava" e logo será encerrado à força pelo sistema.

O problema da abordagem antiga: callbacks e GCD

Antes do async/await, os desenvolvedores usavam Grand Central Dispatch (GCD) e closures (callbacks). Isso levava ao chamado "inferno dos callbacks" — blocos de código aninhados que eram difíceis de ler, depurar e manter.

// Estilo antigo com GCD e closuresfunc fetchUserData(completion: @escaping (User?) -> Void) {    DispatchQueue.global().async {        // Operação longa        let user = User(name: "Ivan")        DispatchQueue.main.async {            completion(user)        }    }}

fetchUserData { user in    guard let user = user else { return }    fetchUserPosts(userId: user.id) { posts in        // Mais um callback aninhado        print(posts)    }}

O Swift moderno oferece uma solução muito mais elegante.

Fundamentos do Swift Concurrency: async/await

Declarando uma função assíncrona

Para tornar uma função assíncrona, adicione a palavra-chave async após a lista de parâmetros. Para chamar essa função, você precisa usar a palavra-chave await.

// Função assíncronafunc fetchImage(from url: URL) async throws -> UIImage {    let (data, _) = try await URLSession.shared.data(from: url)    guard let image = UIImage(data: data) else {        throw URLError(.badServerResponse)    }    return image}

// Chamada da funçãoTask {    do {        let image = try await fetchImage(from: url)        self.imageView.image = image    } catch {        print("Erro ao carregar: \\(error)")    }}

Observe: URLSession.shared.data(from:) já é uma função assíncrona pronta da Apple. Nós apenas a chamamos com await, e a thread é liberada para outras tarefas enquanto os dados são carregados.

Chamadas sequenciais e paralelas

Você pode chamar funções assíncronas de forma sequencial ou paralela.

// Chamada sequencial: a segunda requisição espera a primeiralet user = try await fetchUser(id: 1)let posts = try await fetchPosts(for: user.id)

// Chamada paralela: ambas as requisições executam simultaneamenteasync let user = fetchUser(id: 1)async let posts = fetchPosts(for: 1)let (resultUser, resultPosts) = try await (user, posts)

No modo paralelo, ambas as requisições são iniciadas ao mesmo tempo, o que ```