i just stumbled across this sentence in the `coroutineContex

Question

i just stumbled across this sentence in the `coroutineContext` documentation By convention should contain an instance of a job to enforce structured concurrency What does it mean It spossible that a context does NOT contain a job what are the consequences if a job instance is missing

Dominaezzz · Answer

I haven t checked but maybe when you use `suspend fun main args Array lt String gt `

Dominaezzz · Answer

Since you don t need to use `kotlinx coroutines` for that and that s where `Job` comes from

Dominaezzz · Answer

If `Job` is missing cancellation can t happen I m not sure if I should say easily or not at all here

Marko Mitic · Answer

Dominic is up 24 7 ready to help

Dominaezzz · Answer

sweat smile

gildor · Answer

Just want to add that it s not related on `suspend main` because it doesn t have scope so not related to structured concurrency and scopes this convention only about coroutine scopes implementation because if it doesn t have Job it doesn t have child parent relationship and cannot be cancelled

Dico · Answer

Yeah suspend main runs a simple event loop that s it

Dico · Answer

When kotlinx coroutines isn t present there is no job to speak of unless someone made their own library

Dico · Answer

But CoroutineContext is part of stdlib not kotlinx

thana · Answer

Ahh so the Job is the thing that makes structured concurrency really possible but is introduced by the extension only

gildor · Answer

the extension

thana · Answer

sorry i mean kontlinx coroutine

gildor · Answer

Coroutines cancellation Job Structured Concurrence CoroutineScope all those things are library features of kotlinx coroutine it s not a part of the language

gildor · Answer

But suspend function and CoroutineContext is part of the language

thana · Answer

so basically the native parts are much like java s `Thread` from a structuring point of view

gildor · Answer

not sure how it s comparable

thana · Answer

A `Thread` is basically fire and forget

gildor · Answer

See this is whole coroutines API that available in the language and stdlib <https kotlinlang org api latest jvm stdlib kotlin coroutines index html>

gildor · Answer

No

gildor · Answer

because suspend function is not fire and forget it always returns value or throws exception

gildor · Answer

it just don t have cancellation which has own semantics and just based on the primitives provided by the language

thana · Answer

now i do interpret the essence of structured concurreny is being able to cancle a coroutine or a coroutine scope but i feel this is wrong thinking face

thana · Answer

m really having problems wrapping my head arund coroutines and structured concurrency disappointed

gildor · Answer

see you need structured concurrency when you have some background or parallel work like async launch right

thana · Answer

yes

gildor · Answer

so because there is no way to start background coroutine async and launch do not exist in stdlib than no probblem

thana · Answer

and managing threads has aways been PITA

gildor · Answer

coroutines has nothing to do with managing threads by itself

thana · Answer

ywah but that s what you have to do in java slightly smiling face

gildor · Answer

this is just a feature of kotlinx coroutines which provides dispatcher API

thana · Answer

how would we use coroutines on a world without kotlinx coroutines what would be there use

thana · Answer

oh sequences are part of the stdlib

gildor · Answer

gt ywah but that s what you have to do in java not sure what you mean See coroutines by itself and their basic primitives in stdlib has nothing to do with threading it s language feature to simplify writing asynchronous code in a sequential style that s all it provides you primitives to convert callback to suspend fucntion Threading cancellation scopes async launch etc are features of kotlinx coroutines library which provides high level primitves based on Kotlin Coroutines

gildor · Answer

gt how would we use coroutines on a world without kotlinx coroutines what would be there use They are pretty low level and this is whole point of them For example < C5UPMM0A0|arrow> and some other libraries use coroutines but do not use kotlinx coroutines Again it s just primitives used by other libraries

thana · Answer

you are right i should really change my view on coroutines i alway fall back to the concurrency and multithreading viewl

gildor · Answer

gt how would we use coroutines on a world without kotlinx coroutines what would be there use Just a very simple example which has nothing to do with threading or cancellation Imagine you have this asynchronous API ```fun lt T gt sendRequest onSuccess T gt Unit onError Throwable gt Unit TODO ```

gildor · Answer

so you can see how to use it do something in onSuccess or onError but if you have nested calls or you have some more complicated behavior you have all usual async programming probblems

gildor · Answer

now you convert it to suspend function without dependency on kotlinx coroutines ```suspend fun lt T gt awaitRequest T return suspendCoroutine cont gt sendRequest lt T gt onSuccess = cont resume it onError = cont resumeWithException it ```

gildor · Answer

and use it with suspend main ```suspend fun main val result = awaitRequest lt T gt println result ``` See no callbacks no nesting only stdlib APIs

gildor · Answer

also no cancellation but it s the same as original callback based API

thana · Answer

i see thank you very much slightly smiling face

thana · Answer

gt Since the initial rollout of Kotlin coroutines as an experimental feature in Kotlin 1 1 in the beginning of 2017 we ve been working hard to explain the concept of coroutines to the programmers who used to think of concurrency in terms of threads so our key analogy and motto was coroutines are light weight threads

thana · Answer

i think that s why i always think about threads when i think about coroutines wink

gildor · Answer

yes and it s covered by kotlinx coroutines which has own light weight thread implementation based on coroutines

thana · Answer

well i think roman talks about coroutines in context of the stdlib here it s hard to see a didfference here when you are new to coroutines confused

gildor · Answer

no need to see difference just use kotlinx coroutines This is the way to use them especially if you just started

thana · Answer

smile

gildor · Answer

stdlib coroutines just too low level for every day usage and more like a primitive for library authors

gildor · Answer

The main thing that you should understand what is suspend function

thana · Answer

but then again i come back to my kind of initial question why are `Job`s the crucial point in applying structured concurrency

thana · Answer

<https medium com elizarov structured concurrency 722d765aa952> e g doesn t even mention Jobs yet on almost every api the has to do with `CoroutineScope` or `coroutineContext` it s written that any context should contain a job to enforce structured concurrency

gildor · Answer

Strucutred concurrency is just approach to management of asynchronous background task lifecycle To manage lifecycle aka cancel it when task is not needed anymore to free resources avoid leaks etc you need some abstraction for cancellation And Job is this abstraction You have in simplest and most common case 1 Job per Scope this job become parent for all child coroutines launched from this scope and when you cancel scope all child coroutines are also cancelled

gildor · Answer

gt Note that an implementation of CoroutineScope also defines an appropriate coroutine context for your UI updates You can find a full blown example of CoroutineScope implementation on its documentation page gt <https kotlin github io kotlinx coroutines kotlinx coroutines core kotlinx coroutines coroutine scope index html>

gildor · Answer

it s just simple introduction mostly focused on use case with parallel decomposition where you don t need to work with Job directly

gildor · Answer

gt it s written that any context should contain a job to enforce structured concurrency So I don t see contradiction here

thana · Answer

ok i think i start to grasp it from the beginning coroutines have had a more or less well defined scope they live in but cancellation was the missing piece at least when it comes to longer running backround tasks that we might or might not want to cancel at some point in time

gildor · Answer

StructuredConcurrency just designed in a way when you can run background task only in some scope it can be global but you have to be explicit about it and use `GlobalScope launch` and this scope can be cancelled

gildor · Answer

Imagine if you need scope for every started thread like you cannot start a new thread without ThreadPool it s essenttially the same Than to stop all threads you just cancel thread pool

thana · Answer

but the scope can only be canceled if its context contains a `Job` right

gildor · Answer

That is the thing you cannot cancel scope by itself

gildor · Answer

it s just an interface with `coroutineContext` property

gildor · Answer

But there is extension function `CoroutineScope cancel ` just check what it does

gildor · Answer

gildor · Answer

So scope cancellation is just a convention

thana · Answer

`error Scope cannot be cancelled because it does not have a job $this ` ha

thana · Answer

so maybe finally my understanding allows me to make correct assumptions smile

thana · Answer

thank you very much < gildor> i have much to think about now slightly smiling face