Unpredictable coroutines execution order?

Question

This is what I thought: When using coroutines you go piling up async ops and once you are done with synchronous op..call them in FIFO order..but that's not always true

In this example you get what I expected:

fun main() = runBlocking {
   launch {
      println("1")
   }

   launch {
      println("2")
   }

   println("0")
}

Also here(with nested launch):

fun main() = runBlocking {
   launch {
      println("1")
   }

   launch {
      launch {
         println("3")
      }

      println("2")
   }

   println("0")
}

Now in this example with a scope builder and creating another "pile"(not the real term) the order changes but still..you get as expected

fun main() = runBlocking {
   launch {
      println("2")
   }

   // replacing launch
   coroutineScope {
      println("0")
   }

   println("1")
}

Finally..the reason of this question..example 2 with scope builder:

fun main() = runBlocking {
   launch {
      println("3")
   }

   coroutineScope {
      launch {
         println("1")
      }

      println("0")
   }

   println("2")
}

I get this: 0 3 1 2

Why??

Was my assumption wrong and that's not how coroutines work

If so..then how should I determine the correct order when coding

edited: I've tried running the same code on different machines and different platforms but always got the same result..also tried more complicated nesting to prove non-variability of results

And digging the documentation found that coroutines are just code transformation(as I initially thought)

Remember that even if the like to call them 'light-weight' threads they run in a single 'real' thread(note: without newSingleThreadContext)

Thus I chose to believe execution order is pre-established at compile-time and not decided at runtime

After all..I still can't anticipate the order..and that's what I want

Answer 1

Don't assume coroutines will be run in a specific order, the runtime will decide what's best to run when and in what order. What you may be interested in that will help is the kotlinx.coroutines documentation. It does a great job of explaining how they work and also provides some handy abstractions to help managing coroutines make more sense. I personally recommend checking out channels, jobs, and Deferred (async/await).

For example, if I wanted things done in a certain order by number, I'd use channels to ensure things arrived in the order I wanted.

runBlocking {
    val channel = Channel<Int>()
    launch {
        for (x in 0..5) channel.send(x * x)
        channel.close()
    }

    for (msg in channel) {
        // Pretend we're doing some work with channel results
        println("Message: $msg")
    }
}

Hopefully that can give you more context or what coroutines are and what they're good for.