Why does this Kotlin async code run sequentially if I don't pass a Dispatcher to the async call?

If the following code is run it can be seen that it runs in parallel, as the output looks like this:

> In thread DefaultDispatcher-worker-2 B
BBIn thread DefaultDispatcher-worker-1 A
ABABAABBAAABABAABABABABABABABABAABABABAABBABABAABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAABABABABABAAABBABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB
BBBBB

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.runBlocking


fun main() {
    
    fun long(s: String): Int {
        println("In thread ${Thread.currentThread().name} $s ")
        repeat(100_000) {
            if (it % 1000 == 0) {
                print(s)
            }
        }
        println()
        return 1
    }

    suspend fun doIt() =
        coroutineScope {
            val a = async(Dispatchers.Default) {
                long("A")
            }
            val b = async(Dispatchers.Default) {
                long("B")
            }
        }

    runBlocking {
        doIt()
    }
}

however if I remove the Dispatchers.Default from the async calls, it appears to run sequentially:

> In thread main A
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
In thread main B
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Why is this ? Do you always have to specify a dispatcher to get parallel behaviour ?

When you call launch or async from a coroutine scope it schedule the coroutine to execute in the scope's dispatcher.

So when you call function doIt from runBlocking at main function, you schedule coroutine execution to the single threaded Dispatcher.Main.

As result all coroutines in the scope will be executed sequently.

To change it you can switch context for the whole function doIt

suspend fun doIt() =
        coroutineScope {
            withContext(Dispatchers.Default) {
                val a = async {
                    long("A")
                }
                val b = async {
                    long("B")
                }
            }
        }

or you can switch dispatcher before doIt call

runBlocking {
    withContext(Dispatchers.Default) {
        doIt()
    }
}

Now each new coroutine will be scheduled to Default scheduler which is a multi threaded one.