withContext en Kotlin Coroutines

Requisito previo:

• Corrutinas de Kotlin en Android
• Lanzamiento vs Async en Kotlin Coroutines

Se sabe que async y launch son las dos formas de iniciar la rutina . Dado que se sabe que async se usa para recuperar el resultado, y debe usarse solo cuando necesitamos la ejecución en paralelo, mientras que el lanzamiento se usa cuando no queremos recuperar el resultado y se usa para operaciones como la actualización. de datos, etc. Como sabemos, async es la única forma hasta ahora de iniciar la corrutina y recuperar el resultado, pero el problema con async surge cuando no queremos hacer llamadas de red paralelas. Se sabe que cuando se usa async, se necesita usar la función await () , que conduce al bloqueo del hilo principal, pero aquí viene el concepto de withContext que elimina el problema de bloquear el hilo principal.

withContext no es más que otra forma de escribir el asíncrono donde uno no tiene que escribir await() . Cuando se usa withContext, ejecuta las tareas en serie en lugar de en paralelo. Entonces, uno debe recordar que cuando tenemos una sola tarea en segundo plano y queremos recuperar el resultado de esa tarea, debemos usar withContext. Tomemos un ejemplo que demuestra el funcionamiento de withContext:

// two kotlin suspend functions
// Suppose we have two tasks like below
  
private suspend fun doTaskOne(): String
{
  delay(2000)
  return "One"
}
  
private suspend fun doTaskTwo(): String
{
  delay(2000)
  return "Two"
}

Ejecutemos las dos tareas en paralelo usando async-await y luego usando withcontext y veamos la diferencia entre las dos.

// kotlin function using async
fun startLongRunningTaskInParallel() 
{
  viewModelScope.launch 
  {
    val resultOneDeferred = async { TaskOne() }
    val resultTwoDeferred = async { TaskTwo() }
    val combinedResult = resultOneDeferred.await() + resultTwoDeferred.await()
  }
}

Aquí usando async, ambas tareas se ejecutan en paralelo. Ahora usemos withContext y hagamos la misma tarea en serie con withContext .

// kotlin function using withContext
fun startLongRunningTaskInParallel() 
{
  viewModelScope.launch
  {
    val resultOne = withContext(Dispatchers.IO) { TaskOne() }
    val resultTwo = withContext(Dispatchers.IO) { TaskTwo() }
    val combinedResult = resultOne + resultTwo
  }
}

Aquí se puede ver que en withContext todo es igual, la única diferencia es que aquí no tenemos que usar la función await() , y las tareas se ejecutan de manera serial. Dado que aquí se han realizado múltiples tareas, se debe recordar que async debe usarse con múltiples tareas y withContext debe usarse con una sola tarea. Ahora tomemos un ejemplo e intentemos entender withContext en detalle y cómo se ejecuta.

// sample kotlin program for complete 
// demonstration of withContext
fun testWithContext 
{
  var resultOne = "GFG"
  var resultTwo = "Is Best"
  Log.i("withContext", "Before")
  resultOne = withContext(Dispatchers.IO) { function1() }
  resultTwo = withContext(Dispatchers.IO) { function2() }
  Log.i("withContext", "After")
  val resultText = resultOne + resultTwo
  Log.i("withContext", resultText)
}
  
suspend fun function1(): String
{
  delay(1000L)
  val message = "function1"
  Log.i("withContext", message)
  return message
}
  
suspend fun function2(): String 
{
  delay(100L)
  val message = "function2"
  Log.i("withContext", message)
  return message
}

la función 2 se ejecuta más rápido que la función 1, ya que la función 2 tiene menos demora que la función 1. Dado que withContext es una llamada de suspensión, es decir , no pasará a la siguiente línea hasta que finalice. Dado que withContext es una llamada suspendida y no bloquea el subproceso principal, podemos realizar otras tareas mientras el subproceso IO está ocupado ejecutando la función 1 y la función 2.