Concurrencia en iOS con Swift
4.9 (46 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
181 students enrolled

Concurrencia en iOS con Swift

Domina las librerías Grand Central Dispath y NSOperations con Swift
4.9 (46 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
181 students enrolled
Last updated 4/2020
Spanish
Price: $29.99
30-Day Money-Back Guarantee
This course includes
  • 7 hours on-demand video
  • 26 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Usa las librerías Grand Central Dispatch y NSOperations con Swift
  • Programa en concurrencia y organiza tus tareas por colas, hilos, prioridades...
  • Domina los closures, tareas y a controlar la programación asíncrona
  • Ordena y crea un código más eficiente y reusable
Course content
Expand all 40 lectures 06:59:38
+ Presentación
2 lectures 04:06

Presentación del curso "Concurrencia en iOS con Swift". Versión corta para redes sociales.

Preview 02:16

Bienvenida al curso "Concurrencia en iOS con Swift", contando todos los aspectos del curso, brevemente, para saber cómo será nuestro recorrido por el mismo.

Preview 01:50
+ 1.- Concurrencia, conceptos básicos
4 lectures 29:33

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

Preview 03:25

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.

1.2.- GCD (Grand Central Dispatch)
06:09

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

1.3.- Tipos de colas en GCD y funcionamiento
09:12

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.

1.4.- Caso básico en GCD (barra de progreso)
10:47
+ 2.- Closures
3 lectures 30:13

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.

2.1.- Closures, funciones como valores
02:30

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.

2.2.- Fugas y retenciones de memoria
03:44

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.

2.3.- Ejemplo de closures que escapan y no escapan
23:59
+ 3.- Los problemas de la concurrencia
4 lectures 17:38

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

3.1.- Tipos de problemas
03:02

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

3.2.- Race conditions (condiciones de carrera)
05:40

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.

3.3.- Inversión de la prioridad
04:27

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.

3.4.- Deadlock (bloqueo mortal)
04:29
+ 4.- GCD (Grand Central Dispatch)
8 lectures 01:14:24

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

4.1.- Funcionamiento
03:29

¿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.

4.2.- QoS (Quality of Service)
08:17

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.

Preview 14:21

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

4.4.- Grupos de despachado
11:54

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.

4.5.- Items de trabajo
06:53

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

4.6.- Agrupando y esperando
09:05

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

4.7.- Colas serializadas vs concurrentes
08:11

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.

4.8.- Tareas barrera en colas concurrentes
12:14
+ 5.- Casos prácticos con GCD
5 lectures 01:30:35

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.

5.1.- Carga en lotes de recursos de red
20:05

¿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.

5.2.- Integración la gestión manual de grupos en el sistema
17:24

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.

5.3.- Enumeración concurrente
21:08

¿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.

5.4.- Semáforos
16:27

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

5.5.- Cancelación de bloques
15:31
+ 6.- Operaciones (NSOperation)
10 lectures 01:39:38

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

6.1.- Definición y funcionamiento
08:11

¿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.

6.2.- Colas de operaciones y asincronía
03:39

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).

6.3.- Ejemplo básico de operaciones
08:32

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

6.4.- Ejemplo básico de colas de operaciones
06:29

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

6.5.- Colas del sistema y comportamiento
09:55

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.

6.6.- Añadiendo operaciones en bloque y KVO
18:45

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.

6.7.- Creando nuestras propias operaciones
16:39

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.

6.8.- Colas de operaciones serializadas
06:01

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.

6.9.- Colas dentro de colas con operaciones relacionadas
10:05

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.

6.10.- Cancelación de operaciones
11:22
+ 7.- Casos prácticos de asíncronía con operaciones
4 lectures 01:13:31

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.

7.1.- Creando una subclase de operaciones asíncronas
15:04

¿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.

7.2.- Recuperando varias imágenes de la red (asíncronamente)
11:12

¿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.

7.3.- Varias imágenes de la red y post-procesado (dependencias)
20:12

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.

7.4.- Recuperación a varios niveles, asíncrona
27:03
Requirements
  • Saber desarrollar apps a nivel iniciación en entornos Apple con el lenguaje Swift
  • Conocer y haber trabajado con el lenguaje de programación Swift de Apple y la herramienta Xcode
Description

Bienvenidos a un nuevo curso de Apple Coding Academy para la plataforma Udemy: “Concurrencia en iOS con Swift”.

Te estarás preguntando, ¿qué es eso de la concurrencia? En esencia, es la capacidad de un sistema para ejecutar varias tareas de forma simultánea. Y yo aún diría más, en iOS, es la forma de ordenar las tareas de nuestra app para que se ejecuten a la vez, o en orden, o por partes… para poner orden y control en todas y cada una de las tareas que hacemos en nuestros desarrollos y crear procesos más eficientes que las agrupen y pongan orden en el caos.

En este curso vas a aprender a usar las dos librerías nativas principales de Concurrencia en Swift: Grand Central Dispatch y NSOperations. Con ellas podrás hacer cosas increíbles en tu app que te facilitarán tu trabajo enormemente.

¿Has tenido que llamar alguna vez a una API REST, recuperar un dato, con ese dato hacer otra llamada, coger ese dato y pasarlo a otro lado? ¿O por ejemplo, recuperar un montón de recursos de internet y tener que hacerlo uno a uno y en un código poco entendible e interminable?

En este curso aprenderás a poner orden en tus tareas. A saber organizar tu trabajo. A recuperar toda la información que quieras en un solo paso, o siguiendo el orden correcto, o recuperando varios datos a la vez pero sin saturar el sistema, a darles prioridad a los procesos y sus datos… aprenderás a cómo tu código puede parar y esperar a que las tareas terminen aunque sean asíncronas. A poner orden en el caos, a escribir menos código y que este sea mucho más eficiente y óptimo. Llevarás tus apps y tu código más allá.

La concurrencia es una herramienta esencial para cualquier programador que te permitirá controlar al máximo tus comunicaciones, procesos, tareas, cargas de datos, grabaciones… todo para que tu app sea más eficiente a todos los niveles. Entendiendo cómo fluye tu código, cómo responde, desde dónde, cómo pararlo, ponerlo en marcha y conseguir toda la información que necesitas de la forma más rápida, eficiente y menos pasos.

Consigue hoy este curso único y reinventa tu código desde 0 con estas librerías nativas, con todo el código Swift 5 o superior, usando Xcode 11. O incluso versiones anteriores si así lo necesitas. Domina los procesos, crea tus tareas, contrólalas, por orden y da un paso más allá en tu formación. Entra en un mundo concurrente.

Who this course is for:
  • Desarrolladores de iOS con un mínimo de experiencia en el desarrollo de apps con Swift
  • Desarrolladores de Swift que quieran iniciarse en el desarrollo de apps