Corrutinas de Kotlin en Android

La programación asincrónica es muy importante y ahora es una parte común de las aplicaciones modernas. Aumenta la cantidad de trabajo que su aplicación puede realizar en paralelo. Esto permite ejecutar tareas pesadas lejos de UI Thread en segundo plano, lo que en última instancia brinda una experiencia mejor y más fluida para el usuario de la aplicación.

Corrutina en Kotlin

El equipo de Kotlin define las corrutinas como » subprocesos ligeros «. Son una especie de tareas que los subprocesos reales pueden ejecutar. Las rutinas se agregaron a Kotlin en la versión 1.3 y se basan en conceptos establecidos de otros lenguajes. Las rutinas de Kotlin presentan un nuevo estilo de concurrencia que se puede usar en Android para simplificar el código asincrónico.

La documentación oficial dice que las rutinas son subprocesos ligeros. Por ligero, significa que la creación de rutinas no asigna nuevos subprocesos. En su lugar, utilizan grupos de subprocesos predefinidos y programación inteligente con el propósito de qué tarea ejecutar a continuación y qué tareas más adelante .

Las rutinas son básicamente de dos tipos:

• sin apilamiento
• apilable

Kotlin implementa corrutinas sin pila, lo que significa que las corrutinas no tienen su propia pila, por lo que no se mapean en el subproceso nativo.

¿Por qué necesitamos rutinas?

Como sabemos, los desarrolladores de Android hoy en día tienen muchas herramientas asincrónicas a mano. Estos incluyen RxJava, AsyncTasks, Jobs, Threads. Entonces, ¿por qué hay una necesidad de aprender algo nuevo?

• Mientras usa Rx, requiere mucho esfuerzo para obtenerlo lo suficiente, para usarlo de manera segura. Por otro lado, las tareas asincrónicas y los subprocesos pueden introducir fácilmente fugas y sobrecarga de memoria. Incluso usando estas herramientas después de tantas desventajas, el código puede sufrir devoluciones de llamada , lo que puede introducir toneladas de código adicional. No solo eso, sino que el código también se vuelve ilegible, ya que tiene muchas devoluciones de llamada que, en última instancia, ralentizan o bloquean el dispositivo, lo que provoca una mala experiencia del usuario.
• Android es una plataforma de un solo hilo. Por defecto, todo se ejecuta en el hilo principal. En Android, casi todas las aplicaciones necesitan realizar algunas operaciones que no son de UI como (llamada de red, operaciones de E/S), por lo que cuando no se introduce el concepto de rutinas, lo que se hace es que el programador dedique esta tarea a diferentes subprocesos, cada subproceso ejecuta la tarea dado a él, cuando se completa la tarea, devuelven el resultado al subproceso de la interfaz de usuario para actualizar los cambios necesarios. Aunque en Android se proporciona un procedimiento detallado sobre cómo realizar esta tarea de manera efectiva utilizando las mejores prácticas usando subprocesos, este procedimiento incluye muchas devoluciones de llamada para pasar el resultado entre subprocesos, que finalmente introducen toneladas de código en nuestra aplicación y el el tiempo de espera para que el resultado vuelva a aumentar.
• En Android, cada aplicación tiene un subproceso principal (que maneja todas las operaciones de la interfaz de usuario, como vistas de dibujo y otras interacciones del usuario. Si hay demasiado trabajo en este subproceso principal, como llamadas de red (por ejemplo, buscar una página web), las aplicaciones parecen bloquearse o ralentizarse, lo que conduce a una experiencia de usuario deficiente.

Características de las corrutinas de Kotlin

Coroutines es la solución recomendada para la programación asíncrona en Android. Algunas características destacadas de coroutines se dan a continuación.

• Ligero : se pueden ejecutar muchas corrutinas en un solo subproceso debido a la compatibilidad con la suspensión, que no bloquea el subproceso donde se ejecuta la corrutina. La suspensión libera memoria sobre el bloqueo mientras admite múltiples operaciones simultáneas.
• Soporte de cancelación incorporado : la cancelación se genera automáticamente a través de la jerarquía de rutinas en ejecución.
• Menos fugas de memoria : utiliza concurrencia estructurada para ejecutar operaciones dentro de un ámbito.
• Integración con Jetpack : muchas bibliotecas de Jetpack incluyen extensiones que brindan soporte completo para corrutinas. Algunas bibliotecas también proporcionan su propio ámbito de corrutina que se puede usar para la concurrencia estructurada.

Corrutinas de Kotlin frente a subprocesos

• Obtener los datos de un hilo y pasarlos a otro hilo lleva mucho tiempo. También introduce muchas devoluciones de llamada, lo que reduce la legibilidad del código. Por otro lado, las rutinas eliminan las devoluciones de llamada.
• Crear y detener un hilo es un trabajo costoso, ya que implica crear sus propias pilas, mientras que crear rutinas es muy económico en comparación con el rendimiento que ofrece. Las rutinas no tienen su propia pila.
• Los subprocesos se bloquean, mientras que las corrutinas se pueden suspender. Al bloquear, significa que cuando un subproceso duerme durante un tiempo, todos los subprocesos se bloquean, no puede realizar ninguna otra operación, mientras que, dado que las corrutinas se pueden suspender, cuando se retrasan durante algunos segundos, pueden realizar cualquier otro trabajo.
• Las rutinas ofrecen un nivel muy alto de concurrencia en comparación con los subprocesos, ya que múltiples subprocesos implican bloqueo y cambio de contexto. El cambio de contexto con subprocesos es más lento en comparación con las corrutinas, ya que con los subprocesos, el contexto solo se puede cambiar cuando termina el trabajo de 1 subproceso, pero con las corrutinas, pueden cambiar de contexto en cualquier momento, ya que se pueden suspender.
• Las rutinas son ligeras y súper rápidas. Las corrutinas son más rápidas que los subprocesos, ya que los subprocesos son administrados por el sistema operativo, mientras que las corrutinas son administradas por los usuarios. Tener miles de rutinas trabajando juntas es mucho mejor que tener decenas de subprocesos trabajando juntos.

Dependencias de rutinas de Kotlin

Agregue estas dependencias en el archivo de nivel de aplicación build.gradle .

// dependencies to import in project 
dependencies 
{
  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:x.x.x"
  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x"
}

Nota: xxx es la versión de la rutina.

Ejemplo de corrutinas de Kotlin

Digamos que queremos obtener algunos usuarios de la base de datos y mostrarlos en la pantalla. Para obtener los datos de la base de datos, debemos realizar la llamada de red, buscar al usuario de la base de datos y mostrarlo en la pantalla. La recuperación del usuario se puede realizar mediante devoluciones de llamada o corrutinas .

Uso de devoluciones de llamada:

// pseudo kotlin code for demonstration
// involves a series of callbacks from fetchAndShowUser 
// to fetchUser and then to showUser
fun fetchAndShowUser() 
{
  fetchUser 
  {
    user -> showUser(user)
  }
}

Usando corrutinas:

//pseudo kotlin code for demonstration
suspend fun fetchAndShowUser() 
{
  // fetch on IO thread
  val user = fetchUser() 
  // back on UI thread
  showUser(user)
}

Como se discutió anteriormente, el uso de devoluciones de llamada disminuirá la legibilidad del código, por lo que usar rutinas es mucho mejor en términos de legibilidad y rendimiento también. Como se discutió anteriormente, Coroutines tiene muchas ventajas además de no tener devoluciones de llamada, como que no bloquean, son fáciles y económicas de crear .