DEFAULT

Immediately schedules the coroutine for execution according to its context. This is usually the default option.

DEFAULT uses the default dispatch procedure described in the CoroutineDispatcher documentation.

If the coroutine's Job is cancelled before it started executing, then it will not start its execution at all and will be considered cancelled.

Examples:

// Example of starting a new coroutine that goes through a dispatch
runBlocking {
println("1. About to start a new coroutine.")
// Dispatch the job to execute later.
// The parent coroutine's dispatcher is inherited by default.
// In this case, it's the single thread backing `runBlocking`.
launch { // CoroutineStart.DEFAULT is launch's default start mode
println("3. When the thread is available, we start the coroutine")
}
println("2. The thread keeps doing other work after launching the coroutine")
}
// Example of starting a new coroutine that doesn't go through a dispatch initially
runBlocking {
println("1. About to start a coroutine not needing a dispatch.")
// Dispatch the job to execute.
// `Dispatchers.Unconfined` is explicitly chosen.
launch(Dispatchers.Unconfined) { // CoroutineStart.DEFAULT is the launch's default start mode
println("2. The body will be executed immediately")
delay(50.milliseconds) // give up the thread to the outer coroutine
println("4. When the thread is next available, this coroutine proceeds further")
}
println("3. After the initial suspension, the thread does other work.")
}
// Example of cancelling coroutines before they start executing.
runBlocking {
// dispatch the job to execute on this thread later
launch { // CoroutineStart.DEFAULT is the launch's default start mode
println("This code will never execute")
}
cancel() // cancels the current coroutine scope and its children
launch(Dispatchers.Unconfined) {
println("This code will never execute")
}
println("This code will execute.")
}