What happens to a scope when the system doesn't have a reference to it? As in: • create a class that has a private CoroutineScope attribute • launch something in that scope • do not keep any references to the class What is expected to happen? Will the scope be garbage-collected? If so, what happens to the launched coroutine?

Given that

CoroutineScope

is just an encapsulation of `coroutineContext`: The coroutine will retain a reference to that coroutine context (see

AbstractCoroutine

). So it won't be garbage collected and the coroutine will live on until it completes (normally or cancelled).

I see. So it becomes impossible to cancel the coroutine, and it finishes working normally. When it's done, everything is garbage-collected?

That's what I would expect. Usually one would prefer a coroutine context with some lifecycle support around it: When the respective lifecycle ends, its coroutines would be cancelled.

I believe it's possible that if an unreferenced scope only contains suspended coroutines, the whole thing may get garbage collected without going through the usual cancellation. but I'm not having much luck figuring out how to induce such a situation

For that to be the case, all remaining references would have to be "inside" ones (coroutines referencing the scope and vice versa), but none of the suspended coroutines could be referenced from the outside, right? It would be strange if this could be possible without coroutines entering their completed state. If they are not completed, there must be something referencing them, which could trigger their continuation. But without diving deeply into the countless mechanisms in the coroutines machinery, I can only hypothesize, not prove it.

suspendCoroutine

can suspend a coroutine in a way that doesn't have outside references to its continuation to resume

Hopefully it won't be observable for those who stay away from tinkering with the mechanisms at the level of

suspendCoroutine

. The library's user-facing API should ensure that there is always something watching a suspended continuation, be it a channel, a timer, a flow, whatever. Anything else is hopefully considered a bug and would get fixed. 😇

I've actually done this before, launching simple coroutines that die with the object instead of using an explicit scope. I eventually changed it since it seemed easy to trip up on later (GC'd coroutines never run finally blocks).