[Kotlin] Let me ask you a question about the coroutine suspension function.

I'm studying coroutine, but I have a question because I don't understand it well.

Does the 1.suspend function stop the coroutine at the called place?

suspend fun exampleSuspend() {
     val job1 = CoroutineScope(Dispatchers.IO).async {
         (1..1000).sortedByDescending { it }
         println("job3 Coroutine")
     }
    val job2 = CoroutineScope(Dispatchers.Main).launch {
         val job1Result = job1.await()
        println("job1 Coroutine")
     }
    val job3 = CoroutineScope(Dispatchers.Main).async {
         println("job2 Coroutine")
     }
}

where the exampleSuspend() function has three coroutines.

Among them, job2corutin requires the result of job1corutin.

However, if job1.wait() is executed here, job1 Coroutine does not stop, but

Do you call Coroutine where you called this job1.wait()? It'll be job2 Coroutine here

2. Does the suspend function pause the coroutine even if there is no pause such as delay or wait in the block ({})? (or stop the coroutine and complete the suspend function?)

A combined question of questions 3.1 and 2.

fun main() {
    CoroutineScope(Dispatchers.IO).launch {
        exampleSuspend()
        println("Check..1")
    }
    Thread.sleep(5000)
}
suspend fun exampleSuspend() {
     val job = CoroutineScope(Dispatchers.IO).async {
         (1..1000).sortedByDescending { it }
         println("Check..2")
     }
    job.await()
    println("Check..3")
}

In conjunction with question 1, if wait() stops Coroutine at the called point, job.Awit() is

It is not to pause the job coroutine

My prediction is that Coroutine of main function will exist.

job in exampleSuspend().Because wait() is not inside the job corutin block, but is called from the corutin block of main function.

Therefore, when the file is executed, exampleSuspend() is executed, job coroutine is executed, and also

Job due to asynchronous(?) execution.Await() is also executed and the coroutine of the main function is paused.

That is, println ("Check..)1") is not executed and is stopped until exampleSuspend() is complete.

Then after the job coroutine work, the rest of the code is executed.

The job of exampleSuspend() also has coroutine, so even if coroutine is executed, the code will continue to run, so I can't predict whether Check..2 or Check..3 will be called first.

Check..2

Check..3

Check..1

It runs in order.It's a coincidence.I don't know if wait paused and blocked the execution of job coroutine.

And

job.If wait() is cleared

Check..3

Check..1

Check..2

Runs in order. Maybe it's because there's nothing to wait() for, but the result comes out like this.

It looks like it's exactly asynchronous.

However, this result is linked to question 2, so the suspend function is not stopped unconditionally.

That's what I heard. Is that right? As in question 2, if the suspend function unconditionally pauses the coroutine,

Shouldn't the sampleSuspend() be running and the coroutine of the main function be stopped?

I'm confused. I don't know what's going on.