El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Concurrencia

Siguiente ►
►

La concurrencia es un concepto fundamental en la programación moderna que permite a los programas realizar múltiples tareas al mismo tiempo. En Swift, la concurrencia se maneja principalmente a través de Grand Central Dispatch (GCD) y las operaciones. Este módulo te enseñará cómo utilizar estas herramientas para escribir código concurrente y eficiente.

Objetivos de Aprendizaje

Al final de este módulo, deberías ser capaz de:

  • Comprender los conceptos básicos de la concurrencia.
  • Utilizar Grand Central Dispatch (GCD) para ejecutar tareas en segundo plano.
  • Crear y gestionar colas de operaciones.
  • Implementar tareas asincrónicas y sincronizarlas adecuadamente.

Conceptos Clave

  1. ¿Qué es la Concurrencia?

La concurrencia permite que múltiples tareas se ejecuten de manera superpuesta, mejorando la eficiencia y la capacidad de respuesta de las aplicaciones. En Swift, la concurrencia se puede manejar mediante:

  • Grand Central Dispatch (GCD): Una API de bajo nivel que facilita la ejecución de tareas en segundo plano.
  • Operaciones: Una abstracción de alto nivel sobre GCD que permite una mayor flexibilidad y control.

  1. Grand Central Dispatch (GCD)

GCD es una tecnología de Apple que gestiona colas de tareas y facilita la ejecución de código en segundo plano. Los componentes clave de GCD son:

  • Colas de Despacho (Dispatch Queues): Colas donde se encolan las tareas para su ejecución.
    • Colas Principales (Main Queues): Ejecutan tareas en el hilo principal.
    • Colas Globales (Global Queues): Ejecutan tareas en hilos de fondo.
  • Grupos de Despacho (Dispatch Groups): Permiten agrupar tareas y recibir notificaciones cuando todas las tareas del grupo han finalizado.

  1. Operaciones y Colas de Operaciones

Las operaciones son una abstracción de alto nivel sobre GCD que permite una mayor flexibilidad y control sobre las tareas concurrentes. Los componentes clave son:

  • NSOperation: Una clase base para definir tareas.
  • NSOperationQueue: Una cola que gestiona y ejecuta instancias de NSOperation.

Ejemplos Prácticos

Ejemplo 1: Uso Básico de GCD

import Foundation

// Ejemplo de uso de una cola global para ejecutar una tarea en segundo plano
DispatchQueue.global(qos: .background).async {
    // Tarea en segundo plano
    for i in 1...5 {
        print("Tarea en segundo plano \(i)")
    }
    
    // Volver al hilo principal
    DispatchQueue.main.async {
        print("Tarea en el hilo principal")
    }
}

Explicación:

  • DispatchQueue.global(qos: .background).async {}: Ejecuta la tarea en una cola global de fondo.
  • DispatchQueue.main.async {}: Vuelve al hilo principal para actualizar la interfaz de usuario.

Ejemplo 2: Uso de NSOperation y NSOperationQueue

import Foundation

// Definición de una operación personalizada
class CustomOperation: Operation {
    override func main() {
        if isCancelled {
            return
        }
        for i in 1...5 {
            print("Operación personalizada \(i)")
        }
    }
}

// Creación de una cola de operaciones
let operationQueue = OperationQueue()

// Creación y adición de operaciones a la cola
let operation1 = CustomOperation()
let operation2 = CustomOperation()

operationQueue.addOperation(operation1)
operationQueue.addOperation(operation2)

Explicación:

  • CustomOperation: Una subclase de Operation que define una tarea personalizada.
  • OperationQueue: Una cola que gestiona y ejecuta instancias de Operation.

Ejercicios Prácticos

Ejercicio 1: Tarea en Segundo Plano

Escribe un programa que descargue una imagen desde una URL en segundo plano y la muestre en una UIImageView en el hilo principal.

Solución:

import UIKit

func downloadImage(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 {
            completion(nil)
            return
        }
        DispatchQueue.main.async {
            completion(image)
        }
    }
}

// Uso de la función
let imageView = UIImageView()
if let url = URL(string: "https://example.com/image.jpg") {
    downloadImage(from: url) { image in
        imageView.image = image
    }
}

Ejercicio 2: Sincronización de Tareas

Crea un programa que ejecute tres tareas en segundo plano y muestre un mensaje en el hilo principal cuando todas las tareas hayan finalizado.

Solución:

import Foundation

let dispatchGroup = DispatchGroup()

func performTask(taskNumber: Int) {
    dispatchGroup.enter()
    DispatchQueue.global(qos: .background).async {
        for i in 1...5 {
            print("Tarea \(taskNumber) - Iteración \(i)")
        }
        dispatchGroup.leave()
    }
}

performTask(taskNumber: 1)
performTask(taskNumber: 2)
performTask(taskNumber: 3)

dispatchGroup.notify(queue: .main) {
    print("Todas las tareas han finalizado")
}

Resumen

En este módulo, hemos explorado los conceptos básicos de la concurrencia en Swift, incluyendo el uso de Grand Central Dispatch (GCD) y las operaciones. Aprendimos a ejecutar tareas en segundo plano, sincronizar tareas y gestionar colas de operaciones. Estos conocimientos son esenciales para escribir aplicaciones eficientes y receptivas.

En el próximo módulo, profundizaremos en el Gestor de Paquetes Swift, una herramienta poderosa para gestionar dependencias y paquetes en tus proyectos de Swift.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados