Cancelación cooperativa: isActive y ensureActive
Haga que las corrutinas se puedan cancelar comprobando isActive y llamando a ensureActive.
Cancelación cooperativa: isActive y ensureActive es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.
¿Por qué la cancelación cooperativa?
Las corrutinas de Kotlin usan la cancelación cooperativa: una corrutina cancelada solo se detiene cuando coopera comprobando su estado de cancelación. Un bucle de CPU estrecho no se detendrá hasta realizar esa comprobación.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
var i = 0
while (true) { i++ } // never checks — never cancels!
}
delay(100)
job.cancel()
println("cancel sent but loop kept running until process ended")
}Comprobación de isActive
isActive es una propiedad de CoroutineScope que devuelve false una vez que se solicita la cancelación. Comprobarla en un bucle permite que la corrutina coopere.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
var i = 0
while (isActive) {
i++
}
println("Loop exited after $i iterations")
}
delay(10)
job.cancel()
job.join()
}ensureActive()
ensureActive() lanza CancellationException si la corrutina está cancelada. Es un reemplazo directo de if (!isActive) throw CancellationException().
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
repeat(1_000_000) {
ensureActive() // throws if cancelled
// heavy computation here
}
} catch (e: CancellationException) {
println("Cancelled at iteration")
throw e
}
}
delay(5)
job.cancel()
job.join()
}yield() como punto de cooperación
yield() suspende brevemente la corrutina, lo que permite al planificador comprobar la cancelación y ejecutar otras corrutinas.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
repeat(10) { i ->
yield() // cooperative cancellation point + gives up scheduler
println("Step $i")
}
}
delay(2)
job.cancel()
job.join()
println("Done")
}isActive frente a ensureActive
Use isActive para la lógica condicional (por ejemplo, para salir de un bucle correctamente). Use ensureActive() cuando quiera propagar inmediatamente la cancelación como una excepción.
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
repeat(100) { i ->
if (!isActive) {
println("Stopping at $i, cleaning up...")
return@launch
}
// work
}
}.also { delay(5); it.cancel(); it.join() }
}CancellationException es especial
CancellationException no se propaga al padre: indica una cancelación normal. Nunca la ignore; vuelva a lanzarla o permita que se propague.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
delay(1000)
} catch (e: CancellationException) {
println("Caught cancellation, rethrowing")
throw e // important!
}
}
delay(50)
job.cancel()
job.join()
println("Job state: ${job.isCancelled}")
}Cancelación en trabajo limitado por CPU
Para el trabajo limitado por CPU, inserte ensureActive() o yield() en puntos de comprobación naturales para permitir una cancelación oportuna.
import kotlinx.coroutines.*
suspend fun heavyCompute(n: Int): Long {
var result = 0L
for (i in 0..n) {
ensureActive()
result += i
}
return result
}
fun main() = runBlocking {
val job = launch(Dispatchers.Default) {
println(heavyCompute(1_000_000))
}
delay(10)
job.cancel()
job.join()
}isActive en una función suspend personalizada
Puede acceder a isActive dentro de cualquier función suspend mediante coroutineContext.isActive o usando currentCoroutineContext().isActive.
import kotlinx.coroutines.*
suspend fun checkable() {
while (currentCoroutineContext().isActive) {
delay(10)
println("tick")
}
}
fun main() = runBlocking {
val job = launch { checkable() }
delay(35)
job.cancel()
job.join()
}Cancelación con limpieza de recursos
Incluso con cancelación cooperativa, los recursos se pueden limpiar en bloques finally; la excepción de cancelación sigue propagándose a través de ellos.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
repeat(100) { i ->
ensureActive()
delay(20)
println("Working $i")
}
} finally {
println("Cleanup done")
}
}
delay(50)
job.cancel()
job.join()
}Sondeo con isActive
Los bucles de sondeo son ideales para isActive: siga sondeando hasta que se cancele la corrutina.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
while (isActive) {
println("Polling...")
delay(100)
}
println("Poller stopped")
}
delay(350)
job.cancel()
job.join()
}Diferencia con Thread.interrupted()
A diferencia de los hilos de Java, las corrutinas de Kotlin no dependen de indicadores de interrupción. La cancelación se modela mediante excepciones y el estado del ámbito, lo que permite combinarla y estructurarla.
import kotlinx.coroutines.*
fun main() = runBlocking {
// Kotlin way: cooperative via isActive / ensureActive
launch {
ensureActive()
println("Kotlin coroutine: cancellation is explicit and structured")
}
}Comprobación rápida
¿Qué función lanza una excepción inmediatamente cuando se cancela una corrutina?
Resumen
La cancelación cooperativa requiere puntos de comprobación explícitos: isActive para salir de forma condicional, ensureActive() para lanzar una excepción inmediatamente y yield() para suspenderse y ceder el hilo. Nunca ignore CancellationException.
Aprende Kotlin con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Cancelación cooperativa: isActive y ensureActive» es gratis?
Sí — el texto completo de «Cancelación cooperativa: isActive y ensureActive» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Cancelación cooperativa: isActive y ensureActive»?
Haga que las corrutinas se puedan cancelar comprobando isActive y llamando a ensureActive. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Kotlin Academy?
No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Cancelación cooperativa: isActive y ensureActive»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?
Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Cancelación cooperativa: isActive y ensureActive
- withTimeout y withTimeoutOrNull
- Limpieza con finally y NonCancellable
- Propagación de la cancelación en jerarquías de corrutinas