Filas de Tarefas em Swift: GCD, OperationQueue e Combine para iOS/macOS

Filas de Tarefas para Swift (iOS/macOS): Guia Completo

No desenvolvimento para iOS e macOS, o gerenciamento eficiente de threads e filas de tarefas é a chave para criar aplicativos responsivos e performáticos. O Swift oferece várias ferramentas poderosas para trabalhar com assincronia: desde o clássico Grand Central Dispatch (GCD) até o modelo moderno async/await e o framework Combine. Neste artigo, abordaremos as principais abordagens, suas características e exemplos de uso.

1. Grand Central Dispatch (GCD) — a base do multithreading

GCD é uma biblioteca de baixo nível da Apple para gerenciar a execução paralela de código. O elemento principal é o DispatchQueue, que pode ser serial (serial) ou concorrente (concurrent).

Filas principais:

• main — fila principal (thread da UI). Todas as atualizações da interface devem ser executadas nela.
• global — filas concorrentes do sistema com diferentes prioridades (background, utility, default, userInitiated, userInteractive).
• custom — filas personalizadas, criadas através de DispatchQueue(label:attributes:).

Exemplo: carregar imagem em segundo plano

import UIKit

class ImageLoader {    func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {        DispatchQueue.global(qos: .background).async {            guard let data = try? Data(contentsOf: url),                  let image = UIImage(data: data) else {                DispatchQueue.main.async {                    completion(nil)                }                return            }            DispatchQueue.main.async {                completion(image)            }        }    }}

2. OperationQueue — gerenciamento flexível de tarefas

OperationQueue é uma abstração de nível mais alto sobre o GCD. Permite criar dependências entre operações, definir o número máximo de tarefas paralelas e cancelar operações.

Principais recursos:

• Criação de BlockOperation ou subclasses próprias de Operation.
• Definição de dependências: operation2.addDependency(operation1).
• Cancelamento de todas as operações: queue.cancelAllOperations().
• Controle de qualidade de serviço (quality of service).

Exemplo: carregamento sequencial de arquivos

import Foundation

let queue = OperationQueue()queue.maxConcurrentOperationCount = 1 // execução sequencial

let fetchMetadata = BlockOperation {    print("Carregando metadados...")    Thread.sleep(forTimeInterval: 1)}

let downloadContent = BlockOperation {    print("Carregando conteúdo...")    Thread.sleep(forTimeInterval: 2)}

downloadContent.addDependency(fetchMetadata)

queue.addOperations([fetchMetadata, downloadContent], waitUntilFinished: false)print("Operações enfileiradas")

3. Swift Concurrency (async/await) — abordagem moderna

A partir do Swift 5.5, a Apple introduziu um modelo de assincronia integrado com as palavras-chave async e await. Ele permite escrever código assíncrono de forma linear, sem closures e callbacks.

Componentes principais:

• async — marcação de função assíncrona.
• await — aguardar o resultado de uma operação assíncrona.
• Task — criação de um contexto assíncrono.
• TaskGroup — agrupamento de tarefas paralelas.

Exemplo: carregamento paralelo de dados

import Foundation

func fetchUser(id: Int) async -> String {    // Simulação de requisição de rede    try? await Task.sleep(nanoseconds: 1_000_000_000)    return "User_\\(id)"}

func loadAllUsers() async {    await withTaskGroup(of: String