Lanzamiento vs Async en Kotlin Coroutines

Requisito previo: Kotlin Coroutines en Android

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 .

Hay principalmente dos funciones en Kotlin para iniciar las rutinas . 

• lanzar{ }
• asíncrono{ }

función de lanzamiento

El lanzamiento no bloqueará el hilo principal, pero por otro lado, la ejecución del resto del código no esperará el resultado del lanzamiento ya que el lanzamiento no es una llamada de suspensión. El siguiente es un programa de Kotlin que usa Launch:

// Kotlin Program For better understanding of launch
fun GFG()
{
  var resultOne = "Android"
  var resultTwo = "Kotlin"
  Log.i("Launch", "Before")
  launch(Dispatchers.IO) { resultOne = function1() }
  launch(Dispatchers.IO) { resultTwo = function2() }
  Log.i("Launch", "After")
  val resultText = resultOne + resultTwo
  Log.i("Launch", resultText)
}
 
suspend fun function1(): String
{
  delay(1000L)
  val message = "function1"
  Log.i("Launch", message)
  return message
}
 
suspend fun function2(): String
{
  delay(100L)
  val message = "function2"
  Log.i("Launch", message)
  return message
}

Cuando ejecute el código en el IDE de Android , el resultado del registro será:

// pseudo kotlin code for demonstration of launch
GlobalScope.launch(Dispatchers.Main)
{
  // do on IO thread
  fetchUserAndSaveInDatabase()
}
 
suspend fun fetchUserAndSaveInDatabase()
{
  // fetch user from network
  // save user in database
  // and do not return anything
}

Como no devuelve nada, podemos usar el lanzamiento para completar esa tarea y luego hacer algo en Main Thread.

¿Cuándo usar el lanzamiento?

El lanzamiento se puede usar en lugares donde los usuarios no desean usar el resultado devuelto, que luego se usa para realizar otro trabajo. Por ejemplo, se puede usar en lugares que involucran tareas como actualizar o cambiar un color, ya que en este caso la información devuelta no sería de utilidad.

Función asíncrona

Async también se usa para iniciar las rutinas, pero bloquea el hilo principal en el punto de entrada de la función en el programa. El siguiente es un programa de Kotlin que usa Async:

// kotlin program for demonstration of async
fun GFG
{
  Log.i("Async", "Before")
  val resultOne = Async(Dispatchers.IO) { function1() }
  val resultTwo = Async(Dispatchers.IO) { function2() }
  Log.i("Async", "After")
  val resultText = resultOne.await() + resultTwo.await()
  Log.i("Async", resultText)
}
 
suspend fun function1(): String
{
  delay(1000L)
  val message = "function1"
  Log.i("Async", message)
  return message
}
 
suspend fun function2(): String
{
  delay(100L)
  val message = "function2"
  Log.i("Async", message)
  return message
}

Un punto importante a tener en cuenta es que Async hace que ambas redes llamen a result1 y result2 en paralelo, mientras que con el lanzamiento de funciones paralelas no se realizan llamadas. Cuando ejecute el código en el IDE de Android , el resultado del registro será:

¿Cuándo usar Async?

Cuando realice dos o más llamadas de red en paralelo, pero debe esperar las respuestas antes de calcular la salida, es decir, use async para los resultados de varias tareas que se ejecutan en paralelo. Si usa async y no espera el resultado, funcionará exactamente igual que el lanzamiento.

Tabla de diferencias

A continuación se muestra la tabla de diferencias entre Launch y Async: