Todas las aplicaciones que descargamos y usamos realizan un conjunto de operaciones con el fin de resolver un problema.
Como usuarios, lo primero que queremos es que esas apps no solo funcionen correctamente sino que su experiencia de uso sea agradable.
Sin dudas, el concepto de “agradable” incluye que la interfaz de usuario sea intuitiva y, sobre todo, fluida.
Una aplicación que demore en responder a la interacción del usuario genera cierto desconcierto y puede ser motivo suficiente para convencernos de que debemos eliminarla del dispositivo.
Para evitar que nuestras apps sea una de ellas, es muy importante comprender el concepto de las tareas en segundo plano y aprender sobre GCD.
GCD: Grand Central Dispatch
Cuando hablamos de GCD estamos haciendo referencia a una librería a nivel de sistema que nos permite manejar operaciones concurrentes.
Esto es posible físicamente ya que los dispositivos actuales poseen más de un procesador y por lo tanto, es posible ejecutar en uno de ellos todo el código correspondiente al hilo principal y dejar para el otro (o los otros) las operaciones en segundo plano.
Una aclaración al respecto: las operaciones en background no son exclusivas de los sistemas multi-core. De hecho, existen otras técnicas basadas en software que permiten ejecutar operaciones concurrentes utilizando solo un procesador.
Todo programa esta compuesto por una serie de instrucciones que el procesador debe ejecutar. A esto se le llama thread (o hilo en español).
Por default, todas las instrucciones que escribimos se ejecutan en el hilo principal, una tras otra, y en caso de necesitarlo, es posible crear otros hilos que se ejecutan de manera independiente en otros procesadores.
GCD nos da la posibilidad de no tener que lidiar con la gestión, control y eliminación de threads ni con la necesidad de controlar si se ha llegado al numero máximo permitido.
Simplemente declaramos qué necesitamos correr en segundo plano y lo ejecutamos.
Existe una ley fundamental al momento de usar GCD: todas las operaciones que corresponden a la interfaz de usuario deben ejecutarse en el hilo principal y se deben dejar en segundo plano a todas aquellas que requieran un tiempo considerable de ejecución, como puede ser la descarga de un archivo por la web o la actualización de una base de datos.
En el caso de que se necesite actualizar la interfaz de usuario luego de realizar alguna operación en background, se debe volver al hilo principal y hacer las operaciones correspondientes.
En el inicio de Swift, allá por el 2014, para poder utilizar estas funcionalidades se debían usar algunas instrucciones heredadas de Objective C. Sin embargo, desde la versión 3 del lenguaje, se han incorporado nuevas maneras de utilizar los trabajos en segundo plano que, por cierto, lo hacen mucho más simple.
Terminologia básica. Tasks y Queues
En este post introductorio de GCD vamos a enfocarnos solamente en los conceptos necesarios para poder usar tareas en segundo plano de una manera sencilla.
Dado que la librería en cuestión ofrece un sinfín de posibilidades, podríamos extendernos hablando de sus características, pero creo que para esta primera entrega es suficiente con presentar el tema y dar las herramientas básicas para poder usarlo.
Lo primero que tenemos que hacer al momento de pedirle al sistema que ejecute en background una serie de instrucciones es definir una Task.
Para ser breve, una task es un closure (cerradura en español), o sea, un conjunto de instrucciones definido dentro de un bloque, que permite ser pasado por parámetro a una función y captura los elementos “que lo rodea”, es decir, puede utilizar las variables que se encuentran fuera de su ámbito y recordar su valor.
Una vez que tenemos nuestro código a ejecutar, nuestra Task (o tarea), para poder indicarle a GCD que queremos que sea ejecutada en segundo plano debemos utilizar unas Queues (en español serían colas).
GCD provee lo que se llama Dispatch Queues, o sea, despacho de colas, que se encargan de manejar las tareas, recibiéndolas y ejecutándolas a medida que el procesador dispone de “espacio”.
El orden en que se ejecutan las mismas es PEPS (primero que entra, primero que sale. También conocido como FIFO en Ingles, First In First Out), esto implica que las tareas se van a ir ejecutando en el orden en que fueron agregadas a la cola.
Si bien se puede hacer uso de distintos tipos de queues (unos más prioritarios que otros), por ser el primer acercamiento al tema vamos a usar el queue global con un nivel de prioridad default.
Algo a tener en cuenta es que esta queue también es usado por las APIs de Apple, con lo cual nuestro código no es lo único que va a estar corriendo ahí.
Por último, como ya dijimos anteriormente, cada vez que se requiera actualizar elementos de la interfaz de usuario es necesario usar el thread principal. Para eso, GCD provee una queue que se ejecuta en ese plano y se llama Main.
Manos a la obra
Para pedirle al sistema que ejecute una tarea en segundo plano, debemos ejecutar lo siguiente:
[code lang=»Swift»]
DispatchQueue.global().async {
//Código a ejecutar el segundo plano
}
[/code]
En el caso en el que se requiera actualizar elementos de la interfaz de usuario, se debe invocar al main thread:
[code lang=»Swift»]
DispatchQueue.global().async {
//Código a ejecutar el segundo plano
DispatchQueue.main.async {
//Codigo para actualizar la UI
}
}
[/code]
Existe otra manera de ejecutar tareas en segundo plano indicando un nombre al queue, lo cual nos va a ayudar al momento de debuguear nuestro código ya que aparecerá con el nombre que le indiquemos en el listado de procesos que nos muestra Xcode:
[code lang=»Swift»]
let queue = DispatchQueue(label: «com.ejemplo.introduccionGCD»)
queue.async {
//Código a ejecutar el segundo plano
DispatchQueue.main.async {
//Codigo para actualizar la UI
}
}
[/code]
Esto es todo por este primer post sobre GCD. La idea era que sirviera como introducción al tema y nos permitiera empezar a usar tareas en segundo plano desde ahora.