Hey, I'm launching a long-running coroutine in some scope. Is there a way to obtain its

Job

from my scope later (e.g by marking it in some way)?

launch

allows you to pass in your own

CoroutineContext

. You should be able to put in your own

CoroutineContext.Key

and then obtain it again later.

that seems nice, but how can I retreive this child context from parent scope?

The "parent scope" is a

CoroutineScope

, right? If so, get it's

Job

(every

CoroutineScope

should have one!):

scope.coroutineContext[Job]

. Then search through that Job's children using

job.children

yeah, but how to select one specific

Job

from all children?

You have to find it, by checking if it has your marker key (

CoroutineContext.Key

launch

returns the

Job

of the child, why can’t you just store that? It would be a lot simpler than writing all this search logic.

I didn't notice that job itself is a

CoroutineContext

, thanks

Parents needing references to their child jobs is a common use case – that’s presumably the whole reason why the

launch

API was designed the way it was, to return the child’s

Job

. Using the existing API means you need to write less code (fewer potential bugs) and makes your code’s intent much more obvious than going out of your way to write a bunch of search logic just to avoid creating a variable.

i won't disagree with that, i'm just looking for spicier way to do it

Job.children

returns a list of the job’s child jobs, not their complete contexts.

CoroutineContext

is basically just a strongly-typed

Map<Key, Element>

, where the types of each entry’s keys and values are linked. When you pass a

CoroutineContext

to

launch

, you’re saying “take the current context, add all the entries from the new context to it (existing keys are “overwritten”), and use that as the context for the new coroutine”. So in your example, the child coroutine you launch has a context that looks something like this:

mapOf(
  Job.Key to Job(parent = coroutineContext[Job]),
  JobMarker.Key to JobMarker("a")
)

(there’s some other stuff too, like the dispatcher, but that’s not relevant here) Jobs form a hierarchy, but that hierarchy only includes the jobs themselves, not the entire context. I think the reason for the confusion is that it looks a bit strange that a

Job

“is a”

CoroutineContext

. This doesn’t mean the

Job

contains the whole context, it’s just how the api works, so that, for example, you can pass an instance of

Job

to a function that takes a context and not need a bunch of

job.asCoroutineContext

methods everywhere, and so that the

+

operator can be defined for all of them. All `Job`s are `CoroutineContext`s, not all `CoroutineContext`s are `Job`s.

thanks, that explains a lot

As far as I know, yes.

thanks