Agendador de Tarefas Swift (iOS/macOS)

Agendador de Tarefas Swift (iOS/macOS): Guia Completo

O Agendador de Tarefas (Task Scheduler) é um componente chave no desenvolvimento para iOS e macOS, permitindo gerenciar eficientemente operações assíncronas, tarefas em segundo plano e multithreading. Em Swift, várias ferramentas poderosas estão disponíveis: Grand Central Dispatch (GCD), OperationQueue, o novo mecanismo async/await (Swift Concurrency) e o framework Combine. Neste artigo, vamos detalhar cada um deles, fornecer exemplos de código e recomendações para escolher a ferramenta adequada.

1. Grand Central Dispatch (GCD)

GCD é uma biblioteca de baixo nível para gerenciar tarefas paralelas. Ela trabalha com filas (DispatchQueue) e garante uma distribuição eficiente de threads.

Tipos principais de filas:

main — fila principal (thread da UI).
global — filas em segundo plano com diferentes prioridades (QoS).
private — filas personalizadas (serial ou concurrent).

Exemplo de uso do GCD:

import Foundation

// Tarefa assíncrona em segundo planoDispatchQueue.global(qos: .background).async {    let result = performHeavyComputation()        // Retorna à thread principal para atualizar a UI    DispatchQueue.main.async {        updateUI(with: result)    }}

// Fila serial para execução sequenciallet serialQueue = DispatchQueue(label: "com.example.serial")serialQueue.async {    // Tarefa 1}serialQueue.async {    // Tarefa 2 (executada após a tarefa 1)}

// Fila concorrentelet concurrentQueue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)concurrentQueue.sync {    // Operação bloqueante (cuidado!)}

2. OperationQueue

OperationQueue é uma abstração de nível mais alto sobre o GCD. Ela trabalha com objetos Operation, que podem ser configurados, cancelados e vinculados por dependências.

Vantagens da OperationQueue:

Gerenciamento flexível de dependências entre tarefas.
Suporte embutido para cancelamento e prioridades.
Observação KVO do estado das operações.

Exemplo com BlockOperation:

import Foundation

let operationQueue = OperationQueue()operationQueue.maxConcurrentOperationCount = 2

let operation1 = BlockOperation {    print("Tarefa 1")}let operation2 = BlockOperation {    print("Tarefa 2")}let operation3 = BlockOperation {    print("Tarefa 3")}

// Define dependência: tarefa 3 será executada após as tarefas 1 e 2operation3.addDependency(operation1)operation3.addDependency(operation2)

operationQueue.addOperations([operation1, operation2, operation3], waitUntilFinished: false)

// Cancelar todas as operaçõesoperationQueue.cancelAllOperations()

Criando uma subclasse própria de Operation:

class DownloadOperation: Operation {    private let url: URL        init(url: URL) {        self.url = url    }        override func main() {        guard !isCancelled else { return }        // Executa o download        let data = try? Data(contentsOf: url)        // Processa o resultado    }}

let downloadOp = DownloadOperation(url: URL(string: "https://example.com/data")!)operationQueue.addOperation(downloadOp)

3. Swift Concurrency (async/await)

A partir do Swift 5.5, foi introduzido suporte nativo à programação assíncrona através das palavras-chave async, await e Task. Esta é uma forma moderna e segura de trabalhar com concorrência.