Concurrencia en iOS con Swift

¿Qué es la concurrencia? Vemos en detalle qué es, para qué sirve y cómo la usamos en iOS con Swift.

Grand Central Dispatch, la primera gran API que aprenderemos. Nativa en Swift, nos permite gestionar tareas por colas de trabajo. Veamos en qué consiste y cómo se trabaja con ella.

¿Cuántas colas podemos usar en GCD? ¿Cómo funcionan? Veámoslo en teoría para entenderlo mejor cuando trabajemos con ellas.

Primera sesión de trabajo: vamos a ver qué sucede cuando intentamos tocar la interfaz de la app desde un hilo en segundo plano y cómo evitar que nuestra app se cuelgue. Pero entendiendo por qué pasa esto y por qué hay que hacerlo como explicamos.

Los closures son funciones anónimas. Funciones como valores a guardar en variables o constantes. La base de la programación funcional en Swift. Repasamos cómo funcionan en la teoría.

Un closure no controlado, encierra datos que pueden provocar fugas de memoria, retenciones y un rendimiento inapropiado de nuestra app. Incluso podríamos llegar a tener inestabilidad y cuelgues. Entendemos por qué sucede esto.

Sesión de trabajo para ejemplificar cómo funcionan los distintos closures: los que escapan, los que no y cómo evitar fugas de memoria cuando se encierra a cualquier dato fuera de la semántica del contexto del closure.

¿Qué problemas podemos encontrar si usamos concurrencia? En esta introducción los comentamos.

Hablamos sobre las condiciones de carrera. Qué son, por qué se producen y cómo podemos evitarlas.

Toca el turno de hablar de la inversión de prioridad, un problema derivado del bloqueo de los recursos para evitar precisamente la condición de carrera de la que hablamos en la lección anterior, pero que también es fácil de resolver.

El bloqueo mortal es lo peor que nos puede pasar en nuestra app al usar concurrencia. Aprendemos qué es y cómo evitarlo con unas sencillas buenas prácticas.

Entramos en profundidad en Grand Central Dispatch: ¿cómo funciona? Lo vemos en teoría primero.

¿Qué es la calidad de servicio y cómo nos ayuda a dar distintas prioridades a las tareas? ¿Qué niveles tenemos para usarla? Lo vemos en detalle y para qué sirve cada uno de esos niveles que nos ofrece.

Primera lección práctica en GCD: creamos colas y añadimos tareas de las diferentes formas posibles, incluyendo su programación en el tiempo.

Creamos grupos de despachado en GCD, añadimos tareas, vemos sus posibilidades y cómo usarlos.

Es el turno de los items de trabajo, una forma de encapsular los closures con que trabajamos para añadirlos a colas o grupos de forma más selectiva.

Agrupamos tareas y vemos cómo esperar a que todas ellas finalicen para obtener una respuesta conjunta.

Comparamos el funcionamiento de una cola serializada y de una concurrente, para dejar bien claras sus diferencias y aplicaciones con las tareas en GCD.

Lo mejor de ambos mundos: una cola concurrente que en ocasiones puede comportarse como serializada para tareas concretas etiquetadas como barreras. Vemos su uso y aplicación práctica.

Cargamos recursos de red en lote, y esperamos a obtener una respuesta conjunta. La primera gran aplicación de GCD a nuestro día a día. Un cambio radical en el comportamiento de nuestra app.

¿Cómo podemos integrar los grupos y GCD en otras librerías que nada tengan que ver? Vemos cómo aplicar GCD en las animaciones de la UI y mezclar conceptos que nos ayudarán a un mejor rendimiento y control de nuestra app.

GCD permite hacer enumeraciones concurrentes: muchas tareas que el sistema se encarga de gestionar y que funcionan como un for in de tareas de forma concurrente y ordenada.

¿Cómo se bloquean recursos? ¿Cómo se trabaja para evitar saturar el uso de colas o hilos? Vemos cómo aplicar los semáforos y su uso.

¿Podemos cancelar tareas? Sí, pero bajo unas condiciones especiales que vamos a ver en esta práctica.

Vemos la teoría tras la otra gran API: NSOperations. ¿Cómo funciona y qué diferencias tiene con GCD?

¿Podemos trabajar en asincronía con las operaciones? Podemos, pero en casos especiales porque en principio no. Vamos a aprender la teoría tras esto, además de cómo funcionan las colas de operaciones.

Comenzamos las sesiones de práctica en NSOperations: cómo creamos una operación, como le añadimos nuevos bloques o incluso usamos su bloque de completado (que lo tiene).

¿Para qué sirven las colas de operaciones? Vemos todos los ejemplos prácticos de uso para conocer cómo y dónde usarlas.

El sistema también ofrece dos colas que podemos usar para colocar operaciones: veamos cuáles son y para qué se usan.

Las operaciones se conforman con el patrón KVO (Key-Value Observing) así que podemos registrarnos a cualquier cambio de determinadas propiedades en las mismas. Vamos a ver cómo añadir operaciones en bloque, esperar a todas ellas y registrarnos a la finalización de una en concreto.

Podemos crear nuestras propias operaciones, creando subclases de Operations, la clase principal de las operaciones y padre de nuestras BlockOperation. Vamos a ver qué interesantes ventajas aporta este uso.

Si las operaciones son concurrentes y las colas también: ¿podemos hacer colas serializadas? Sí y no. Vamos a ver qué significa eso y cómo simular este comportamiento.

Las colas pueden contener otras colas, anidar operaciones en ellas y obtener notificaciones por niveles. Vamos a ver un ejemplo práctico que nos saque de dudas de los casos en que es práctico hacerlo.

Las operaciones también se pueden cancelar, pero en esta ocasión con una funcionalidad mucho más ventajosa que en las tareas en GCD. Veamos un ejemplo práctico para entender esta sutil pero importante diferencia.

Si queremos usar asincronía, tenemos que crear una subclase de Operations y manejar la máquina de estados de las operaciones por nuestra cuenta. Creemos esa subclase que nos servirá para cualquier proyecto donde queramos usar clases asíncronas.

¿Cuántas imágenes voy a recuperar de la red? Las que haya en un array: pero da igual. Las bajaremos todas y nuestro hilo se esperará que todas ellas hayan bajado para seguir ejecutando el código.

¿Y si no sé cuántas imágenes tengo que descargar porque me lo dice un JSON que está en mi API REST? Da igual, bajamos ese JSON, y luego todas las imágenes que nos dice. Todo en una sola operación usando dependencias.

Vamos a explotar las dependencias al máximo: voy a la red varias veces porque el primer JSON contiene la dirección del segundo. Y este segundo una imagen que también he de descargar. Y además quiero post-procesar esa imagen. Hagamos todo en una sola operación para entender cómo implementar las dependencias a nivel interno y esperemos a que nuestro código funcione cuando todo ello haya terminado. Una prueba compleja de hasta dónde podemos llegar con las operaciones con menos de 100 líneas de código.