Cancelamento cooperativo: isActive e ensureActive
Torne corrotinas canceláveis verificando isActive e chamando ensureActive.
Cancelamento cooperativo: isActive e ensureActive é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.
Por que usar cancelamento cooperativo?
As corrotinas do Kotlin usam cancelamento cooperativo: uma corrotina cancelada só é interrompida quando coopera verificando seu estado de cancelamento. Um laço intensivo de CPU não será interrompido até verificar esse estado.
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")
}Verificando isActive
isActive é uma propriedade de CoroutineScope que retorna false assim que o cancelamento é solicitado. Verificá-la em um laço faz a corrotina cooperar.
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() lança CancellationException se a corrotina for cancelada. É um substituto direto para 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 ponto de cooperação
yield() suspende brevemente a corrotina, permitindo que o agendador verifique o cancelamento e execute outras corrotinas.
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 versus ensureActive
Use isActive para lógica condicional (por exemplo, para sair de um laço de forma elegante). Use ensureActive() quando quiser propagar o cancelamento imediatamente como uma exceção.
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 é especial
CancellationException não é propagada para o pai — ela sinaliza um cancelamento normal. Nunca a engula; sempre a lance novamente ou 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}")
}Cancelamento em trabalho limitado pela CPU
Para trabalhos limitados pela CPU, insira ensureActive() ou yield() em pontos de verificação naturais para permitir um cancelamento oportuno.
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 em uma função suspensa personalizada
Você pode acessar isActive dentro de qualquer função suspensa por meio de coroutineContext.isActive ou 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()
}Cancelamento com limpeza de recursos
Mesmo com o cancelamento cooperativo, os recursos podem ser limpos em blocos finally — a exceção de cancelamento ainda se propaga por eles.
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()
}Sondagem com isActive
Os laços de sondagem são ideais para isActive: continue sondando até que a corrotina seja cancelada.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
while (isActive) {
println("Polling...")
delay(100)
}
println("Poller stopped")
}
delay(350)
job.cancel()
job.join()
}Diferença em relação a Thread.interrupted()
Ao contrário das linhas de execução do Java, as corrotinas do Kotlin não dependem de sinalizadores de interrupção. O cancelamento é modelado por meio de exceções e do estado do escopo, o que o torna componível e estruturado.
import kotlinx.coroutines.*
fun main() = runBlocking {
// Kotlin way: cooperative via isActive / ensureActive
launch {
ensureActive()
println("Kotlin coroutine: cancellation is explicit and structured")
}
}Verificação rápida
Qual função lança imediatamente uma exceção quando uma corrotina é cancelada?
Recapitulação
O cancelamento cooperativo exige pontos de verificação explícitos: isActive para sair condicionalmente, ensureActive() para lançar imediatamente, yield() para suspender e ceder a linha de execução. Nunca engula CancellationException.
Aprenda Kotlin com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “Cancelamento cooperativo: isActive e ensureActive” é grátis?
Sim — o texto completo de “Cancelamento cooperativo: isActive e ensureActive” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.
O que vou aprender em “Cancelamento cooperativo: isActive e ensureActive”?
Torne corrotinas canceláveis verificando isActive e chamando ensureActive. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Kotlin Academy?
Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Cancelamento cooperativo: isActive e ensureActive”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Kotlin Academy?
Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Cancelamento cooperativo: isActive e ensureActive
- withTimeout e withTimeoutOrNull
- Limpeza com finally e NonCancellable
- Propagação de cancelamento em hierarquias de corrotinas