Despachadores en Kotlin Coroutines

Requisito previo: Kotlin Coroutines en Android

Se sabe que las corrutinas siempre se inician en un contexto específico, y ese contexto describe en qué subprocesos se iniciará la corrutina. En general, podemos iniciar la corrutina usando GlobalScope sin pasarle ningún parámetro, esto se hace cuando estamos sin especificar el subproceso en el que se debe iniciar la rutina. Este método no nos da mucho control sobre ella, ya que nuestra corrutina se puede lanzar en cualquier hilo disponible, por lo que no es posible predecir el hilo en el que se han lanzado nuestras corrutinas.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
  
        // coroutine launched in GlobalScope
        GlobalScope.launch() {
        Log.i("Inside Global Scope ",Thread.currentThread().name.toString())
            // getting the name of thread in
            // which our coroutine has been launched
        }
  
        Log.i("Main Activity ",Thread.currentThread().name.toString())
    }
}

la salida del registro se muestra a continuación:

Podemos ver que no se puede predecir el subproceso en el que se inicia la rutina, a veces es DefaultDispatcher-worker-1, o DefaultDispatcher-worker-2 o DefaultDispatcher-worker-3.

¿Cómo resuelven los despachadores el problema anterior?

Los despachadores ayudan a las corrutinas a decidir el subproceso en el que se debe realizar el trabajo. Los despachadores se pasan como argumentos a GlobalScope mencionando qué tipo de despachadores podemos usar según el trabajo que queremos que haga la corrutina. 

Tipos de Despachadores

Hay principalmente 4 tipos de Despachadores.

1. Despachador principal
2. Despachador de E/S
3. Despachador predeterminado
4. Despachador no confinado

Despachador principal:

Comienza la rutina en el hilo principal. Se usa principalmente cuando necesitamos realizar las operaciones de la interfaz de usuario dentro de la rutina, ya que la interfaz de usuario solo se puede cambiar desde el subproceso principal (también llamado subproceso de la interfaz de usuario).

GlobalScope.launch(Dispatchers.Main) {
       Log.i("Inside Global Scope ",Thread.currentThread().name.toString())
           // getting the name of thread in which 
              // our coroutine has been launched
       }
       Log.i("Main Activity ",Thread.currentThread().name.toString())

Despachador de E/S:

Inicia la corrutina en el subproceso IO, se usa para realizar todas las operaciones de datos, como redes, lectura o escritura desde la base de datos, lectura o escritura en los archivos, por ejemplo: Obtener datos de la base de datos es una operación IO, que se realiza en el subproceso IO.

GlobalScope.launch(Dispatchers.IO) {
       Log.i("Inside IO dispatcher ",Thread.currentThread().name.toString())
           // getting the name of thread in which
              // our coroutine has been launched
       }
       Log.i("Main Activity ",Thread.currentThread().name.toString())

Despachador predeterminado:

Inicia la corrutina en el subproceso predeterminado. Deberíamos elegir esto cuando planeamos hacer cálculos complejos y de larga ejecución, que pueden bloquear el subproceso principal y congelar la interfaz de usuario, por ejemplo: supongamos que necesitamos hacer los 10,000 cálculos y estamos haciendo todos estos cálculos en el subproceso de la interfaz de usuario, es decir, principal subproceso, y si esperamos el resultado o 10,000 cálculos, hasta ese momento nuestro subproceso principal se bloqueará y nuestra interfaz de usuario se congelará, lo que provocará una experiencia de usuario deficiente. Entonces, en este caso, necesitamos usar el subproceso predeterminado. El despachador predeterminado que se usa cuando se lanzan corrutinas en GlobalScope está representado por Dispatchers. Predeterminado y utiliza un grupo de subprocesos de fondo compartido, por lo que launch(Dispatchers.Default) { … } utiliza el mismo despachador que GlobalScope.launch { … }.

GlobalScope.launch(Dispatchers.Default) {
        Log.i("Inside Default dispatcher ",Thread.currentThread().name.toString())
            // getting the name of thread in which 
              // our coroutine has been launched
        }
        Log.i("Main Activity ",Thread.currentThread().name.toString())

Despachador no confinado:

Como sugiere el nombre, el despachador no confinado no se limita a ningún subproceso específico. Ejecuta la continuación inicial de una corrutina en el marco de llamada actual y permite que la corrutina se reanude en cualquier subproceso que utilice la función de suspensión correspondiente, sin exigir ninguna política específica de subprocesos.