I have the code ``` runBlocking val one = async function1 va

Question

I have the code ``` runBlocking val one = async function1 val two = async function2 one await ``` Even though I just call `one await ` I see that function 2 is executed as well Can anyone explain why is it so I was under the impression that calling `await ` is what triggers the execution

streetsofboston · Answer

It is not lazy Provide LAZY as input to the async call if you like it to be lazy

Shashank · Answer

so does it start all the async blocks defined till now

streetsofboston · Answer

A call to `async` runs the Coroutine as soon as possible unless you provide a different value for its `start` parameter LAZY If you do provide the value LAZY it doesn t run the Coroutine until `start` or `await` and such is called on the returned `Job` or `Deferred`

streetsofboston · Answer

Sam Schilling · Answer

`val two = async start = CoroutineStart LAZY function2 `

Shashank · Answer

Thanks a lot guys slightly smiling face

Dominaezzz · Answer

Don t forget to explicitly call `await ` before the scope exits Otherwise you get deadlock

Shashank · Answer

Yeah just got one sweat smile

Dominaezzz · Answer

lol

Shashank · Answer

Shouldn t it just finish normally if I never await or start a lazy async

streetsofboston · Answer

I think it should but it doesn t slightly smiling face

streetsofboston · Answer

But opinions on this subject vary slightly smiling face

Shashank · Answer

Interesting Do you know where I can read up on the varying opinions

Dominaezzz · Answer

If you explicitly specify lazy you must explicitly `await ` seems fair

Dominaezzz · Answer

``` runBlocking val one = async start = CoroutineStart LAZY function1 val two = async function2 delay 1000 one await ```

Dominaezzz · Answer

Library doesn t know if you re going to await at some point even if the scope has ended

Shashank · Answer

Ahh that makes sense But if the scope has reached the end and I haven t called await it isn t a far fetched assumption that I don t want to await on that async

streetsofboston · Answer

Probably because you could provide the deferred result from `async start = LAZY ` to an external class actor piece of code and it could decide to call `await` at any given time even if it is hours later

streetsofboston · Answer

Would be nice to have a compiler lint warning for local lazy Deferred values that can detect if `await` has not been called and a risk of deadlock is there

Dominaezzz · Answer

The lint would be just as good as the calling blocking IO in non IO dispatcher lint

Dominaezzz · Answer

Although I guess the library could see that the only coroutines left are the lazy ones

Dominaezzz · Answer

But what order should they be awakened in though

Dominaezzz · Answer

Too many questions to answer