Cooperative cancellation limits for non-suspending coroutine work

Short answer

Cancelling a parent Job immediately marks the child Job as cancelled, so isCancelled becomes true without waiting for a suspension point. It does not preemptively stop the child's running code. A CPU-bound loop that never suspends keeps executing until it finishes or voluntarily checks cancellation. Cascading cancellation is complete only when every child job reaches a terminal state.

Confirmed behavior

• parent.cancel() propagates the cancellation signal to child jobs immediately; the child Job reports isCancelled = true even while its coroutine body is still running on the CPU.
• Kotlin coroutine cancellation is cooperative. The running coroutine observes cancellation only at suspension points such as yield(), delay(), withContext(), or join(), or through explicit checks such as isActive and ensureActive().
• During a non-suspending loop, isActive and isCancelled can both be true at the same time. Cancellation alone does not mean the coroutine has stopped.
• parent.join() does not return until all children are terminal. A non-cooperative child can therefore block join() indefinitely.
• Cascading cancellation is complete when every child job has moved to Completed or Cancelled. For non-cooperative work, that requires the work to exit voluntarily or an external mechanism outside coroutine cancellation.

Verification steps for this case

1. Launch the child inside the parent scope.
2. Cancel the parent.
3. Inside the child's tight loop, log job.isActive, job.isCancelled, and coroutineContext.isActive on each iteration.
4. Add yield() or ensureActive() to the loop and confirm CancellationException is thrown at the first suspension point after cancellation.
5. Call parent.join() and confirm it does not return while the non-cooperative loop continues.

val parent = CoroutineScope(SupervisorJob() + Dispatchers.Default)
val child = parent.launch {
    val job = coroutineContext[Job]!!
    while (true) {
        println("active=${job.isActive} cancelled=${job.isCancelled}")
    }
}
parent.cancel()
child.join() // may not return while the loop runs

Assumptions

This assumes kotlinx.coroutines structured concurrency with a standard Job hierarchy. Custom Job implementations or unusual schedulers may behave differently; use the job-state logs above to verify.

Missing diagnostic detail

Can you modify the child coroutine body to add suspension points or explicit cancellation checks? If not, coroutine cancellation alone cannot stop the work, and you need an external mechanism such as thread interruption or an isolated scope not tied to the cancelled parent.