Dispatchers y withContext

Al terminar esta lección, guardar el torneo en un fichero JSON y calcular la tabla de posiciones ocurrirán fuera del hilo de la pantalla (el que atiende la pantalla y el teclado; en Android se le llama «hilo principal»), cada cosa en el grupo de hilos que le corresponde, y las dos a la vez. Verás en consola el nombre del hilo en que corre cada bloque y qué mensaje da Kotlin cuando pides un hilo que no existe.

Importa porque dónde corre el código decide si un programa responde o se queda congelado. Hoy la consola no lo notaría; en la app Android, un cálculo largo en el hilo equivocado congela la pantalla. Temas: Dispatchers Main, IO y Default, y withContext.

Quién decide en qué hilo corre una corrutina

Una corrutina no es un hilo (lo viste en Corrutinas y suspend): es trabajo que se puede pausar. Pero para avanzar necesita un hilo del sistema que la ejecute. Quien elige ese hilo es el dispatcher («despachador»): un elemento del contexto de la corrutina que reparte el trabajo entre hilos.

Lo nuevo es que un dispatcher se puede sustituir: launch(Dispatchers.Default) y withContext(Dispatchers.Default) cambian solo el dispatcher y dejan lo demás del contexto como estaba.

Ojo con dos «main» distintos. El hilo que se llama main en tu consola es solo el hilo con el que arranca el programa: no es Dispatchers.Main. Dispatchers.Main es el hilo de la pantalla, y solo existe donde hay una interfaz gráfica que lo aporte (Android, una ventana de escritorio). En una consola no hay, y lo comprobarás con un error real más abajo.

Concurrencia y paralelismo, ahora con hilos de verdad

En launch y async viste que, dentro de runBlocking, hay un solo hilo: las corrutinas se turnan (concurrencia). Dispatchers.Default cambia eso: con 11 núcleos, hasta 11 corrutinas pueden calcular a la vez, cada una en su hilo y su núcleo (paralelismo real). En cambio, esperar con delay es concurrencia aunque haya muchos hilos: ninguna corrutina ocupa hilo mientras espera, y por eso 10.000 pueden esperar a la vez.

withContext: cambiar de hilo sin cambiar de forma de escribir

withContext(dispatcher) { … } ejecuta el bloque en ese dispatcher, espera a que termine, devuelve su resultado y vuelve al dispatcher de origen. Para quien lee el código sigue siendo una función normal, de arriba abajo.

import kotlinx.coroutines.*
 
suspend fun demo() {
    // Thread.currentThread().name es el nombre del hilo que ejecuta esta línea
    println("Empiezo en: ${Thread.currentThread().name}")            // main
    val texto = withContext(Dispatchers.IO) {   // pasa al grupo de hilos de disco y red y espera
        // startsWith(«…») dice si un texto empieza por esas letras: aquí, si el hilo es del grupo compartido
        println("Dentro, en un worker: ${Thread.currentThread().name.startsWith("DefaultDispatcher-worker")}")
        "leído del disco"                       // lo último del bloque es lo que devuelve withContext
    }
    println("Vuelvo a: ${Thread.currentThread().name} con «$texto»") // main
}
 
fun main() = runBlocking {   // runBlocking corre en el hilo de arranque, que se llama «main»
    demo()
}

Al ejecutarlo, imprime:

Empiezo en: main
Dentro, en un worker: true
Vuelvo a: main con «leído del disco»

En el Kotlin Playground de la web el hilo puede tener otro nombre; lo que importa es que el de «Empiezo en» y el de «Vuelvo a» sean el mismo.

Dos consecuencias que importan:

• withContext es el patrón de las funciones «seguras para llamar desde cualquier sitio». Quien llama no tiene que saber que dentro se cambia de hilo.
• Al volver, vuelves al dispatcher de origen aunque el bloque haya terminado en otro. En runBlocking eso es el mismo hilo (main); si partías de Default, vuelves a Default, pero quizá a otro hilo de ese grupo. No hay que volver al hilo original a mano: withContext lo hace solo.

Error típico: bloquear un hilo de Default

Default tiene pocos hilos, tantos como núcleos. Si una corrutina bloquea su hilo (lo deja parado sin liberarlo), los demás encargos hacen cola. Thread.sleep bloquea; delay suspende y libera el hilo. Es la misma idea que viste en Corrutinas y suspend, ahora con 1.000 corrutinas en Default.

runBlocking {
    repeat(1000) {
        launch(Dispatchers.Default) { Thread.sleep(100) }   // el hilo se queda parado
    }
}

runBlocking {
    repeat(1000) {
        launch(Dispatchers.Default) { delay(100) }          // el hilo se libera mientras espera
    }
}

Medido en un Mac de 11 núcleos (las cifras varían de una ejecución a otra y dependen de tu máquina, sobre todo de cuántos núcleos tenga):

Con Thread.sleep, solo 11 corrutinas avanzan a la vez (una por hilo, en paralelo) y las demás esperan turno. Con delay, las 1.000 esperan a la vez, en concurrencia, porque ninguna ocupa hilo. Una función bloqueante es la que deja su hilo parado hasta que termina. Si de verdad hay que llamar a una (leer un fichero, una llamada de red antigua), no se hace en Default: se envuelve en withContext(Dispatchers.IO), que admite muchos más hilos parados a la vez.

Default corre en un worker: true
Default es otro hilo: true
Tras salir, el mismo hilo del principio: true
leído

import kotlinx.coroutines.*
 
fun hilo() = Thread.currentThread()
 
// La función bloqueante se envuelve en IO: quien la llame no tiene que saberlo.
suspend fun leerLento(): String = withContext(Dispatchers.IO) {
    Thread.sleep(200)
    "leído"
}
 
fun main() = runBlocking {
    val inicial = hilo()                                     // el hilo en el que empieza runBlocking
    withContext(Dispatchers.Default) {
        println("Default corre en un worker: ${hilo().name.startsWith("DefaultDispatcher-worker")}")
        println("Default es otro hilo: ${hilo() !== inicial}")
    }
    println("Tras salir, el mismo hilo del principio: ${hilo() === inicial}")
    println(leerLento())
}

Paso · Guardar en IO y calcular en Default

Objetivo. Crear SegundoPlano.kt con tres funciones que guardan el torneo, lo cargan y calculan la tabla fuera del hilo que las llama, más cerrarJornada, que hace las dos cosas a la vez. Al terminar, ./gradlew :torneo:run imprime un bloque nuevo de siete líneas: el título, cuatro con nombres de hilo, el guardado y el mensaje de Dispatchers.Main.

Esta lección no instala nada: la librería de corrutinas que añadiste en Corrutinas y suspend ya trae los tres dispatchers. Guardar y cargar usan lo que escribiste en Guardado.kt en Marcador (guardar y cargarTorneo).

Qué hacer en cada fichero (el código completo está más abajo):

1. Crea SegundoPlano.kt. En torneo → kotlin+java, clic derecho sobre el paquete com.sebastiannarvaez.marcador.torneo → New → Kotlin Class/File → File → escribe SegundoPlano y pulsa Intro. Se abre con solo la línea package.
2. Abre Ejemplo.kt (doble clic en su nodo, dentro del mismo paquete). Dentro de object Ejemplo, justo antes de la llave } que lo cierra (la última del fichero), añade torneoConPartidos(): Torneo, que devuelve un Torneo nuevo, llamado «Copa Barrio», con los cuatro equipos que Ejemplo ya define (rayo, toros, lobos y aguilas) y los partidos rayoContraToros y lobosContraAguilas ya registrados.
3. Abre Main.kt y haz tres cambios:
   • Dos import nuevos (kotlinx.coroutines.withContext y java.io.File), debajo de los que ya hay arriba. Si prefieres, escribe el nombre en el código y pulsa Option+Enter sobre la palabra en rojo: Android Studio añade el import por ti.
   • La llamada demoDispatchers(), al final del bloque runBlocking de main, tras demoTransmisorPropio(), y delante de ella el println del título.
   • La función demoDispatchers(), justo debajo de la llave que cierra main. Usa try/catch y no runCatching, y el porqué se explica más abajo.
4. El test se copia con el botón, al final.

torneo.json lo escribe el programa al ejecutarse: no lo creas tú.

Tres detalles antes de escribir:

• partidos ya devuelve una copia (toList(), de Inmutabilidad y referencias), así que val copiaDePartidos = partidos guarda una lista que nadie más modifica. Torneo es mutable y no está preparado para que otro hilo lo lea mientras alguien registra un partido; al otro hilo solo viaja esa copia.
• cerrarJornada usa dos async (launch y async): guardar (en IO) y calcular (en Default) arrancan a la vez, y como son hilos distintos pueden avanzar en paralelo real. getOrThrow() (Result: errores como valores) lanza el error si guardar falló.
• La demo usa try/catch con IllegalStateException, no runCatching: runCatching atraparía también la CancellationException, justo lo que Alcance, Job y cancelación enseña a evitar. Y las líneas «IO corre en» y «Default corre en» no salen de las funciones de SegundoPlano.kt (guardar no debe escribir en pantalla), sino de dos withContext que demoDispatchers abre aparte solo para enseñar el nombre del hilo de cada dispatcher.

Piezas nuevas de este paso: una función de extensión suspend con withContext (tal como en el ejemplo de arriba) y dos async en dispatchers distintos. Lo demás ya lo has usado: Thread.currentThread().name, getOrThrow(), try/catch de un tipo concreto con e.message (Excepciones: try, catch y require, «Varios catch»), !== para saber que dos referencias no son el mismo objeto (data class e igualdad) y fichero.absolutePath, la ruta completa de un fichero.

Intenta escribirlo tú, en este orden:

1. En SegundoPlano.kt, tres funciones que se pueden llamar desde cualquier hilo: guardarEnSegundoPlano(fichero) guarda el torneo en IO; cargarTorneoEnSegundoPlano(fichero) lo carga también ahí; y tablaEnSegundoPlano() calcula la tabla en Default, trabajando sobre una copia de los partidos, los equipos y el reglamento; la tabla se calcula como en f1, con partidos.tablaDePosiciones(equipos, reglas).
2. cerrarJornada(fichero) guarda y calcula la tabla a la vez; si guardar falla, lanza el error, y si no, devuelve la tabla.
3. En Ejemplo.kt, torneoConPartidos() devuelve un torneo «Copa Barrio» con los cuatro equipos del ejemplo y sus dos partidos ya registrados.
4. En Main.kt, demoDispatchers() dice en qué hilo empieza, cierra la jornada en torneo.json, muestra dónde guardó y quién lidera, dice en qué hilo vuelve e intenta usar el dispatcher Main, que en un programa de consola no existe, mostrando el error sin que el programa se caiga. Para mostrar el nombre del hilo de cada dispatcher, abre un momento IO y Default solo con ese fin.

Tras las demos anteriores, debe verse (el número del worker cambia de una ejecución a otra, y «IO» y «Default» pueden salir en el orden contrario):

== guardar en IO y calcular la tabla en Default ==
Empiezo en: main
IO corre en: DefaultDispatcher-worker-2
Default corre en: DefaultDispatcher-worker-2
Guardado en …/torneo.json; líder: Rayo FC con 3 puntos
Vuelvo a: main
Dispatchers.Main: Module with the Main dispatcher is missing. Add dependency providing the Main dispatcher, e.g. 'kotlinx-coroutines-android' and ensure it has the same version as 'kotlinx-coroutines-core'

Cuando termines, abre el bloque y compara.

package com.sebastiannarvaez.marcador.torneo
 
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.withContext
import java.io.File
 
// Un Dispatcher decide EN QUÉ HILOS corre una corrutina:
//   Dispatchers.Default -> tantos hilos como núcleos; para CALCULAR.
//   Dispatchers.IO      -> muchos hilos, pensado para ESPERAR (disco, red).
//   Dispatchers.Main    -> el hilo de la interfaz. Solo existe donde hay UI
//                          (Android, Swing…): en una consola no lo hay.
//
// `withContext(dispatcher) { ... }` cambia de hilo durante el bloque, espera a
// que acabe y devuelve su resultado. La función que lo llama sigue siendo
// secuencial para quien la lee.
 
// Escribir el JSON es esperar al disco: IO.
suspend fun Torneo.guardarEnSegundoPlano(fichero: File): Result<Unit> =
    withContext(Dispatchers.IO) { guardar(fichero) }
 
suspend fun cargarTorneoEnSegundoPlano(fichero: File): Result<Torneo> =
    withContext(Dispatchers.IO) { cargarTorneo(fichero) }
 
// Calcular la tabla es CPU: Default. Se toma una copia de los partidos ANTES de
// cambiar de hilo: el Torneo es mutable y no está preparado para que otro hilo
// lo lea mientras alguien registra un partido.
suspend fun Torneo.tablaEnSegundoPlano(): List<FilaDePosicion> {
    val copiaDePartidos = partidos
    val equiposInscritos = equipos
    val reglas = reglamento
    return withContext(Dispatchers.Default) { copiaDePartidos.tablaDePosiciones(equiposInscritos, reglas) }
}
 
// Las dos cosas a la vez, cada una en su dispatcher. Si el guardado falla, se
// lanza el error (`getOrThrow`) al esperar el resultado.
suspend fun Torneo.cerrarJornada(fichero: File): List<FilaDePosicion> = coroutineScope {
    val guardado = async { guardarEnSegundoPlano(fichero) }
    val tabla = async { tablaEnSegundoPlano() }
    guardado.await().getOrThrow()
    tabla.await()
}

    // Un torneo nuevo cada vez (el Torneo es mutable) con los dos partidos ya jugados.
    fun torneoConPartidos(): Torneo = Torneo("Copa Barrio", listOf(rayo, toros, lobos, aguilas)).apply {
        registrar(rayoContraToros).getOrThrow()
        registrar(lobosContraAguilas).getOrThrow()
    }

import kotlinx.coroutines.withContext
import java.io.File

        println("== guardar en IO y calcular la tabla en Default ==")
        demoDispatchers()

suspend fun demoDispatchers() {
    val torneo = Ejemplo.torneoConPartidos()
    val fichero = File("torneo.json")
    println("Empiezo en: ${Thread.currentThread().name}")
    withContext(Dispatchers.IO) { println("IO corre en: ${Thread.currentThread().name}") }
    withContext(Dispatchers.Default) { println("Default corre en: ${Thread.currentThread().name}") }
    val tabla = torneo.cerrarJornada(fichero)
    println("Guardado en ${fichero.absolutePath}; líder: ${tabla.first().equipo.nombre} con ${tabla.first().puntos} puntos")
    println("Vuelvo a: ${Thread.currentThread().name}")
    // Dispatchers.Main en consola: no existe.
    try {
        withContext(Dispatchers.Main) { }
    } catch (e: IllegalStateException) {
        println("Dispatchers.Main: ${e.message}")
    }
}

El test: se copia con el botón

SegundoPlanoTest.kt (7 pruebas: ida y vuelta del JSON, la tabla, cerrarJornada y un guardado imposible) comprueba lo que acabas de escribir y no enseña dispatchers más allá de lo que ya has visto, así que se copia con el botón Copiar fichero.

1. En torneo → kotlin+java, clic derecho sobre el paquete com.sebastiannarvaez.marcador.torneo (test) → New → Kotlin Class/File → File → escribe SegundoPlanoTest y pulsa Intro.
2. Pulsa Copiar fichero en el bloque de abajo.
3. En el editor, selecciona todo y pega: Cmd+A / Cmd+V. El texto copiado trae su propia línea package.

Entre las siete hay una que comprueba que, en una consola, pedir Dispatchers.Main falla con IllegalStateException (es el error de la caja de arriba), y otra que comprueba, como en el ejercicio, que withContext(Dispatchers.Default) cambia de hilo y al salir vuelve al de antes.

Lo que has visto

IO y Default comparten el mismo grupo de hilos: por eso «IO» y «Default» pueden salir con el mismo worker. Y quien llama a cerrarJornada sigue escribiendo código en línea recta: no se ve que por dentro hay hilos.

== guardar en IO y calcular la tabla en Default ==
Empiezo en: main
IO corre en: DefaultDispatcher-worker-2
Default corre en: DefaultDispatcher-worker-2
Guardado en …/torneo.json; líder: Rayo FC con 3 puntos
Vuelvo a: main
Dispatchers.Main: Module with the Main dispatcher is missing. Add dependency providing the Main dispatcher, e.g. 'kotlinx-coroutines-android' and ensure it has the same version as 'kotlinx-coroutines-core'