Colas de tareas en Swift: GCD, OperationQueue y Swift Concurrency

Colas de tareas en Swift: desde GCD hasta Swift Concurrency

En el desarrollo para iOS y macOS, la gestión de la ejecución paralela del código es una de las tareas clave. Las colas de tareas (queues) permiten distribuir eficientemente la carga entre los hilos sin bloquear la interfaz de usuario. En esta guía analizaremos tres enfoques principales: el clásico Grand Central Dispatch (GCD), la abstracción OperationQueue y el mecanismo moderno Swift Concurrency (async/await).

1. Grand Central Dispatch (GCD) — la base del paralelismo

GCD es una biblioteca de bajo nivel en C, integrada en Swift. Gestiona un grupo de hilos y proporciona dos tipos de colas:

• Serial (secuenciales) — las tareas se ejecutan una tras otra en el orden en que se añaden.
• Concurrent (paralelas) — las tareas se inician simultáneamente, no se garantiza el orden de finalización.

Ejemplo de creación y uso de una cola:

import Foundation

// Creamos una cola seriallet serialQueue = DispatchQueue(label: "com.example.serial")

serialQueue.async {    print("Tarea 1 iniciada")    sleep(1)    print("Tarea 1 completada")}

serialQueue.async {    print("Tarea 2 iniciada")    sleep(1)    print("Tarea 2 completada")}

// Cola concurrentelet concurrentQueue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)

concurrentQueue.async {    print("Tarea paralela A")}

concurrentQueue.async {    print("Tarea paralela B")}

Características clave de GCD:

• DispatchQueue.main — cola principal (hilo de UI).
• DispatchQueue.global(qos: .userInitiated) — colas globales con prioridad (QoS).
• dispatchGroup — sincronización de múltiples tareas.
• dispatchSemaphore — control de acceso a recursos.

2. OperationQueue — abstracción orientada a objetos

OperationQueue está construida sobre GCD, pero proporciona una API de más alto nivel. Principales ventajas:

• Gestión de dependencias entre operaciones.
• Cancelación de tareas (cancel).
• Monitoreo de estado (isFinished, isExecuting).
• Número máximo de operaciones paralelas.

Ejemplo con BlockOperation:

import Foundation

let operationQueue = OperationQueue()operationQueue.maxConcurrentOperationCount = 2

let operation1 = BlockOperation {    print("Operación 1: cargando datos")    sleep(2)    print("Operación 1 completada")}

let operation2 = BlockOperation {    print("Operación 2: procesando")    sleep(1)    print("Operación 2 completada")}

// Establecemos dependencia: la operación 2 comenzará solo después de que finalice la operación 1operation2.addDependency(operation1)

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

// Cancelación de operaciónoperation1.cancel()

Cuándo usar OperationQueue:

• Cadenas complejas de tareas con dependencias.
• Necesidad de control detallado (pausa, cancelación).
• Trabajo con KVO (Key-Value Observing) para monitoreo.

3. Swift Concurrency — enfoque moderno (iOS 13+, macOS 10.15+)

A partir de Swift 5.5, Apple introdujo soporte nativo para programación asíncrona mediante async/await, Task y TaskGroup. Es una forma más segura y legible de trabajar con paralelismo.

Ejemplo básico:

import Foundation

func fetchUserData() async -> String {    // Simulación de solicitud de red    try? await Task.sleep(nanoseconds: 2 * 1_000_000_000)    return "Datos de usuario cargados"}

func processData()