Filas de Tarefas em Swift: GCD, OperationQueue e Swift Concurrency

Filas de Tarefas para Swift (iOS/macOS): GCD, OperationQueue e Swift Concurrency

O desenvolvimento para iOS e macOS requer gerenciamento eficiente de tarefas paralelas. As filas de tarefas (Task Queues) são um mecanismo fundamental para criar aplicativos responsivos e performáticos. Em Swift, existem três abordagens principais: o clássico Grand Central Dispatch (GCD), o orientado a objetos OperationQueue e o moderno async/await (Swift Concurrency). Neste artigo, analisaremos detalhadamente cada um deles com exemplos práticos.

1. Grand Central Dispatch (GCD) — DispatchQueue

GCD é uma biblioteca de baixo nível em linguagem C, embutida no núcleo do sistema. Em Swift, é representada pela classe DispatchQueue. Permite executar blocos de código de forma sequencial ou concorrente.

Tipos principais de filas:

• Main Queue — fila sequencial que opera na thread principal. Usada para atualizar a UI.
• Global Queues — filas concorrentes com diferentes prioridades (QoS: userInteractive, userInitiated, utility, background).
• Custom Queues — filas personalizadas (sequenciais ou concorrentes).

Exemplo: Carregamento assíncrono de dados com atualização da UI

import UIKit

class ViewController: UIViewController {    @IBOutlet weak var imageView: UIImageView!

    func loadImage(from url: URL) {        // Mudamos para a fila de fundo        DispatchQueue.global(qos: .userInitiated).async { [weak self] in            guard let data = try? Data(contentsOf: url),                  let image = UIImage(data: data) else { return }

            // Retornamos à thread principal para atualizar a UI            DispatchQueue.main.async {                self?.imageView.image = image            }        }    }}

Trabalhando com semáforos e grupos

let group = DispatchGroup()let queue = DispatchQueue.global()

group.enter()queue.async {    print("Tarefa 1 concluída")    group.leave()}

group.enter()queue.async {    print("Tarefa 2 concluída")    group.leave()}

group.notify(queue: .main) {    print("Todas as tarefas concluídas")}

2. OperationQueue e Operation

OperationQueue é uma camada sobre o GCD, fornecendo uma interface orientada a objetos. Cada tarefa é uma instância da classe Operation (ou sua subclasse BlockOperation). Principais vantagens: gerenciamento de dependências, cancelamento de tarefas e configuração do número máximo de operações paralelas.

Exemplo: Carregamento com dependências

let queue = OperationQueue()queue.maxConcurrentOperationCount = 2

let fetchData = BlockOperation {    print("Carregando dados...")}

let processData = BlockOperation {    print("Processando dados...")}

let updateUI = BlockOperation {    print("Atualizando interface")}

// Definimos dependências: processData será executado após fetchDataprocessData.addDependency(fetchData)updateUI.addDependency(processData)

queue.addOperations([fetchData, processData, updateUI], waitUntilFinished: false)

Prioridades e cancelamento de tarefas

let operation = BlockOperation {    if Task.isCancelled { return }    print("Executando...")}operation.queuePriority = .veryHigh

// Cancelamento da operaçãooperation.cancel()

3. Swift Concurrency (async/await)

A partir do Swift 5.5, a Apple apresentou um modelo de assincronicidade integrado. O async/await permite escrever código assíncrono de forma linear, sem closures. Componentes principais: Task, TaskGroup, actor.

Exemplo: Carregamento assíncrono de imagem

import UIKit

class ImageLoader {    func loadImage(from url: URL) async throws -> UIImage {        let