Concurrencia en Kotlin: hilos, corrutinas y async/await para principiantes

Kotlin vs Python: ¿quién gana? La batalla por la concurrencia

Si estás leyendo este material en PythonLib, lo más probable es que ya estés familiarizado con Python y su GIL (Global Interpreter Lock), que convierte el multihilo en un dolor de cabeza. Escribes threading, esperas un aumento de velocidad, y obtienes… código síncrono con un toque de bloqueos. ¿Te suena familiar?

¡Bienvenido al mundo de Kotlin! Es un lenguaje que decidió: «Hagamos la concurrencia cómoda, rápida y sin dolor». En este artículo analizaremos tres enfoques para la concurrencia en Kotlin: los hilos clásicos, las corrutinas modernas y el potente dúo async/await. Aprenderás a escribir código asíncrono que no te explote la cabeza y por qué Kotlin es una excelente opción para el desarrollo backend y Android.

1. Hilos en Kotlin: ¿un viejo amigo es mejor que dos nuevos?

Empecemos por lo básico. Los hilos (threads) en Kotlin son los mismos hilos que en Java. Kotlin funciona en la JVM, por lo que tienes acceso a todo el poder de java.lang.Thread. Pero seamos honestos: los hilos son como conducir un coche sin airbags. Funciona, pero da miedo.

¿Cómo crear un hilo en Kotlin?

La forma más sencilla:

fun main() {\n    thread {\n        println("Saludo desde el hilo: ${Thread.currentThread().name}")\n    }\n    println("Hilo principal: ${Thread.currentThread().name}")\n}

Parece familiar, ¿verdad? Pero hay un detalle: los hilos son pesados. Cada hilo es un recurso del sistema separado. Si creas 10,000 hilos, tu programa fallará con un OutOfMemoryError o se ralentizará como una computadora vieja con Windows 95.

Problemas de los hilos:

\n
• Alto consumo de memoria — cada hilo reserva una pila (~1 MB).
\n
• Complejidad de sincronización — bloqueos, deadlocks, race conditions. Recuerda synchronized en Java y llora.
\n
• Cambio de contexto — el SO pierde tiempo cambiando entre hilos.
\n

Para proyectos pequeños, los hilos pueden servir. Pero si estás construyendo un servicio de alta carga o una aplicación con miles de tareas paralelas, es hora de mirar hacia las corrutinas.

2. Corrutinas en Kotlin: ligeras como una pluma

Las corrutinas (coroutines) son «hilos con esteroides». No están vinculadas a hilos del sistema y pueden ejecutarse en un solo hilo, cambiando entre tareas sin la intervención del SO. ¿Suena complicado? En la práctica, es simple y elegante.

Primera corrutina

Para trabajar con corrutinas necesitarás la dependencia kotlinx-coroutines-core. Pero si usas Kotlin 1.3+, ya está integrada.

import kotlinx.coroutines.*\n\nfun main() = runBlocking {\n    launch {\n        delay(1000L)\n        println("¡Mundo después de la pausa!")\n    }\n    println("Hola,")\n}

¿Qué está pasando aquí?

\n
• runBlocking — bloquea el hilo principal hasta que todas las corrutinas internas terminen. Para aprender está bien, para producción úsalo con precaución.
\n
• launch — inicia una nueva corrutina. No bloquea el hilo, simplemente se suspende en delay.
\n
• delay — análogo a Thread.sleep(), pero no bloqueante. La corrutina simplemente se «duerme» y libera el hilo para otras tareas.
\n

Resultado: primero se imprime «Hola,» y después de un segundo, «¡Mundo después de la pausa!». Sin bloqueos, sin hilos adicionales.

¿Por qué las corrutinas son mejores que los hilos?

\n
• Ligereza — ¿Un millón de corrutinas? ¡Fácil! No crean hilos separados.
\n
• Suspensión — una corrutina puede detenerse en cualquier momento y continuar después.
\n
• Concurrencia estructurada — las corrutinas viven en un ámbito (scope) y se cancelan automáticamente si el scope finaliza.
\n

Despachadores (Dispatchers