O custo oculto do Grand Central Dispatch em apps de produção
Durante mais de dez anos, o Grand Central Dispatch (GCD) foi a ferramenta padrão para tirar trabalho pesado da thread principal no iOS. Quase todo código legado mistura chamadas de DispatchQueue.global().async com retornos em DispatchQueue.main.async, semáforos manuais e closures encadeadas em três ou quatro níveis.
O problema do GCD em aplicativos grandes vai muito além da estética do código aninhado. Quando várias filas concorrentes ficam bloqueadas aguardando I/O ou DispatchSemaphore.wait(), o runtime do libdispatch continua criando novas threads do sistema operacional para compensar as bloqueadas. Esse fenômeno, conhecido como explosão de threads (thread explosion), consome cerca de 512 KB de memória de pilha por thread criada e força o agendador do kernel a gastar ciclos preciosos em trocas de contexto. Soma-se a isso a inversão de prioridade (uma fila de prioridade baixa segurando um lock aguardado pela Main Thread) e condições de corrida silenciosas sobre dicionários compartilhados, que passam despercebidas nos testes locais e só explodem sob carga real nos aparelhos dos clientes.
A concorrência nativa introduzida no Swift 5.5 e endurecida no modo estrito do Swift 6 muda a base do modelo. Em vez de criar threads soltas sob demanda, o runtime mantém um pool cooperativo com um número de threads próximo à quantidade de núcleos da CPU. Quando uma função encontra um await, a execução é suspensa em uma estrutura leve alocada na heap (uma continuação) e a thread fica livre imediatamente para atender outra tarefa.
Regra fundamental do pool cooperativo: nunca bloqueie uma thread dentro de código async usando DispatchSemaphore.wait(), Thread.sleep() ou I/O síncrono demorado. Como o pool tem poucas threads fixas, bloquear algumas delas pode paralisar todo o aplicativo em deadlock.
async/await com cancelamento cooperativo
Substituir closures com Result<T, Error> por async throws elimina esquecimentos clássicos (como sair de um guard sem chamar o completion handler) e devolve o fluxo natural de do/try/catch. Mais importante ainda: o cancelamento deixa de depender de flags booleanas artesanais e passa a trafegar automaticamente pela hierarquia da Task.
No exemplo abaixo, o serviço de conta verifica o cancelamento antes de decodificar um payload grande de JSON, evitando desperdiçar CPU quando o usuário já saiu da tela:
import Foundation
public enum AccountServiceError: Error, Sendable {
case invalidURL
case unexpectedStatus(Int)
}
public final class AccountService: Sendable {
private let session: URLSession
private let baseURL: URL
public init(baseURL: URL, session: URLSession = .shared) {
self.baseURL = baseURL
self.session = session
}
public func fetchBalance(accountId: String) async throws -> AccountBalance {
let url = baseURL.appendingPathComponent("v1/accounts/\(accountId)/balance")
let (data, response) = try await session.data(from: url)
try Task.checkCancellation()
guard let http = response as? HTTPURLResponse else {
throw AccountServiceError.unexpectedStatus(-1)
}
guard (200...299).contains(http.statusCode) else {
throw AccountServiceError.unexpectedStatus(http.statusCode)
}
return try JSONDecoder().decode(AccountBalance.self, from: data)
}
} Concorrência estruturada: quando usar async let e TaskGroup
Ao carregar uma tela inicial que depende de três endpoints independentes (saldo, lista de cartões e alertas), executar os três em série desperdiça tempo de espera de rede. Se o número de chamadas é fixo e os tipos de retorno são diferentes, async let é a forma mais legível e segura: o compilador garante que todas as tarefas filhas terminem (ou sejam canceladas em caso de erro) antes de a função retornar.
Já quando o volume é dinâmico (por exemplo, buscar detalhes de 30 lançamentos ou baixar miniaturas), entra o withThrowingTaskGroup. Uma armadilha comum em produção é jogar 50 itens no grupo de uma só vez e saturar o servidor ou estourar o limite de conexões simultâneas do dispositivo. A boa prática é limitar a concorrência ativa dentro do próprio grupo:
public func fetchReceipts(
ids: [String],
maxConcurrent: Int = 4
) async throws -> [Receipt] {
try await withThrowingTaskGroup(of: Receipt.self) { group in
var iterator = ids.makeIterator()
var results: [Receipt] = []
results.reserveCapacity(ids.count)
for _ in 0..<min(maxConcurrent, ids.count) {
if let id = iterator.next() {
group.addTask { try await self.fetchReceipt(id: id) }
}
}
for try await receipt in group {
results.append(receipt)
if let nextId = iterator.next() {
group.addTask { try await self.fetchReceipt(id: nextId) }
}
}
return results
}
} O diagrama abaixo mostra como a fronteira de interface (@MainActor), o grupo estruturado de tarefas no pool cooperativo e o isolamento de estado em um actor trabalham juntos sem locks manuais:
Actors e a armadilha da reentrância em produção
O tipo actor protege propriedades internas garantindo que apenas uma tarefa execute código síncrono dentro dele por vez. Porém, existe uma pegadinha sutil que já causou bugs sérios em produção mesmo para engenheiros experientes: actors em Swift são reentrantes.
Na prática, isso significa que toda vez que um método do actor encontra um ponto de suspensão (await), o isolamento é liberado temporariamente para evitar deadlocks. Enquanto a primeira tarefa espera uma resposta HTTP de renovação de token, uma segunda tarefa pode entrar no mesmo método do actor, ver que o token ainda está expirado e disparar uma segunda chamada de refresh em paralelo. Em muitos provedores OAuth com rotação de refresh token, essa segunda chamada invalida a sessão inteira e desloga o usuário no meio do uso.
A solução idiomática é guardar a Task em andamento dentro do próprio actor para que todas as chamadas concorrentes aguardem o resultado da mesma requisição (request coalescing):
public actor AuthTokenVault {
private var currentToken: SessionToken?
private var inFlightRefresh: Task<SessionToken, Error>?
private let refreshClient: TokenRefreshClient
public init(refreshClient: TokenRefreshClient) {
self.refreshClient = refreshClient
}
public func validToken() async throws -> SessionToken {
// Se já existe um refresh em andamento, aguarda o mesmo resultado
if let existingTask = inFlightRefresh {
return try await existingTask.value
}
if let token = currentToken, !token.isExpired {
return token
}
let task = Task {
try await refreshClient.requestNewToken()
}
inFlightRefresh = task
defer { inFlightRefresh = nil }
let freshToken = try await task.value
currentToken = freshToken
return freshToken
}
} Esse padrão de AuthTokenVault se encaixa diretamente nos fluxos de autenticação descritos em segurança e fluxos de autenticação em mobile banking. Já na camada de apresentação (Presenters em VIP ou ViewModels em MVVM-C), aplicar @MainActor no tipo de interface garante em tempo de compilação que nenhuma atualização de componente UIKit ou SwiftUI aconteça fora da thread principal; vale revisar como essa separação organiza times maiores em Clean Swift (VIP) vs. MVVM-C.
GCD vs. Swift Concurrency na prática
Antes de decidir o ritmo de migração de uma base existente, ajuda enxergar lado a lado o que muda no comportamento em tempo de execução e compilação:
| Dimensão | Grand Central Dispatch (GCD) | Swift Concurrency (Swift 5.5 / 6) |
|---|---|---|
| Alocação de threads | Cria threads de sistema conforme filas bloqueiam (risco de thread explosion). | Pool cooperativo fixo próximo ao número de núcleos da CPU. |
| Detecção de Data Races | Apenas em tempo de execução via Thread Sanitizer (TSan) e crashes em campo. | Verificada em tempo de compilação com Sendable e isolamento de actors. |
| Propagação de cancelamento | Manual por meio de DispatchWorkItem ou flags booleanas. | Automática em árvore dentro de async let e TaskGroup. |
| Risco de Retain Cycles | Alto; exige vigilância constante de [weak self] em closures aninhadas. | Reduzido; atenção concentrada em Task de longa duração e AsyncStream. |
| Interoperabilidade com legado | Nativa em APIs antigas de UIKit e SDKs C/Objective-C. | Ponte limpa com withCheckedThrowingContinuation. |
Roteiro seguro para migrar para Swift 6 Strict Concurrency
Tentar ligar o modo completo do Swift 6 de uma vez em um projeto de 300 mil linhas costuma gerar milhares de alertas e travar a equipe inteira. O caminho que funciona em produção é incremental, de baixo para cima na árvore de dependências:
- Comece pelos módulos folha (Modelos, DTOs e Networking), marcando structs imutáveis e enums de erro como
Sendable. - Ative
SWIFT_STRICT_CONCURRENCY = targetednos targets já preparados e só suba paracompletequando o módulo zerar os alertas. - Desconfie de
@unchecked Sendable: use somente quando o tipo realmente tiver sincronização interna comprovada (comoOSAllocatedUnfairLock) e documente a invariante em um comentário curto. - Ao encapsular SDKs legados com
withCheckedThrowingContinuation, garanta que cada caminho possível (sucesso, erro e cancelamento) chameresumeexatamente uma vez; chamar zero vezes gera vazamento silencioso da task e chamar duas vezes derruba o app em produção. - Evite usar
Task.detachedsem necessidade real: tarefas soltas perdem a herança de prioridade, valores deTaskLocale cancelamento estruturado do contexto pai.
Vale atenção especial também ao testar código assíncrono em Swift. Em vez de colocar chamadas de Task.sleep(for:) espalhadas nos testes unitários (que deixam a suíte lenta e instável em máquinas de CI carregadas), injete protocolos de relógio (Clock) ou dependências determinísticas para disparar retomadas sob controle exato do teste. Quando você combina testes determinísticos com o isolamento garantido pelo compilador, a migração deixa de ser um risco de regressão e passa a remover bugs de concorrência que estavam escondidos na base havia anos.
