Agendador de Tarefas Swift: GCD, OperationQueue e Timer no iOS/macOS

Agendador de Tarefas Swift (iOS/macOS): GCD, OperationQueue e Timer

No desenvolvimento para iOS e macOS, o gerenciamento de tarefas assíncronas, execuções atrasadas e multithreading é a base do desempenho e da capacidade de resposta dos aplicativos. Em Swift, três componentes principais são usados para isso: GCD (Grand Central Dispatch), OperationQueue e Timer. Neste artigo, analisaremos cada um deles em detalhes, mostraremos exemplos de código e explicaremos quando usar cada um.

1. Grand Central Dispatch (GCD) — DispatchQueue

GCD é uma API C de baixo nível que o Swift disponibiliza através de DispatchQueue. Ele permite executar tarefas de forma assíncrona, paralela ou sequencial, gerenciando threads automaticamente.

Tipos principais de filas:

• Main Queue — fila serial, executa tarefas na thread principal (UI).
• Global Queues — filas paralelas com diferentes prioridades (background, user-initiated, utility).
• Custom Serial/Concurrent Queues — criadas pelo desenvolvedor.

Exemplo: carregamento assíncrono de dados

import Foundation

// Obtém a fila global de backgroundDispatchQueue.global(qos: .background).async {    // Trabalho pesado (parse, download)    let data = try? Data(contentsOf: URL(string: "https://example.com/data.json")!)        // Retorna à thread principal para atualizar a UI    DispatchQueue.main.async {        // Atualiza a interface        print("Dados carregados: \\(data?.count ?? 0) bytes")    }}

Execução atrasada (dispatch_after)

let deadline = DispatchTime.now() + 3.0 // após 3 segundosDispatchQueue.main.asyncAfter(deadline: deadline) {    print("3 segundos se passaram")}

Grupos de tarefas (DispatchGroup)

let group = DispatchGroup()

group.enter()DispatchQueue.global().async {    // Tarefa 1    Thread.sleep(forTimeInterval: 2)    group.leave()}

group.enter()DispatchQueue.global().async {    // Tarefa 2    Thread.sleep(forTimeInterval: 1)    group.leave()}

// Notificação de conclusão de todas as tarefasgroup.notify(queue: .main) {    print("Todas as tarefas concluídas")}

2. OperationQueue — agendador de alto nível

OperationQueue é construído sobre o GCD, mas oferece mais flexibilidade: é possível definir dependências entre operações, prioridades, cancelar tarefas individuais e limitar o número máximo de operações paralelas.

Criação e execução de operações

let queue = OperationQueue()queue.maxConcurrentOperationCount = 2 // no máximo 2 tarefas paralelas

let operation1 = BlockOperation {    print("Operação 1")    Thread.sleep(forTimeInterval: 1)}

let operation2 = BlockOperation {    print("Operação 2")    Thread.sleep(forTimeInterval: 1)}

// Define dependência: operation2 só começará após operation1operation2.addDependency(operation1)

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

Cancelamento de operações

operation1.cancel() // Cancela a operação se ela ainda não estiver em execução

// Verificação de cancelamento dentro da operaçãolet cancellableOp = BlockOperation {    if !cancellableOp.isCancelled {        print("Executando")    }}

Características principais do OperationQueue:

• É possível definir qualityOfService (prioridade).
• As operações podem ser objetos Operation com o método main() sobrescrito.
• Suporta KVO (Key-Value Observing) para monitoramento de estado.

3. Timer — para tarefas periódicas e atrasadas

Timer (anteriormente NSTimer) é usado para executar código em intervalos definidos. Importante: os timers funcionam n