Startup mode and scope builder of collaboration in kotlin

---

The startup mode of the coroutine

1.DEFAULT: After the collaboration is created , Start scheduling immediately , If the collaboration is cancelled before scheduling , It will go directly to the state of canceling the response .
2.ATOMIC: After the collaboration is created , Start scheduling immediately , The coroutine does not respond to cancellation until it reaches the first hang point
3.LAZY: Only when collaboration is needed , Including the method of actively calling the coroutine start、join perhaps await Wait for the function to start scheduling , If it is cancelled before scheduling , Then the collaboration will directly enter the abnormal end state .
4.UNDISPATCHED: The coroutine is executed in the current function call stack immediately after it is created , Until you meet the first real hang point .

@Test
    fun `test start mode`() = runBlocking {
    
        /* val job1 = launch(start = CoroutineStart.DEFAULT) { delay(10000) println("Job finished.") } delay(1000) job1.cancel() val job2 = launch(start = CoroutineStart.ATOMIC) { //... This paragraph must be implemented  delay(10000) // Here is the first starting point  println("Job finished.") } delay(1000) job2.cancel() val job3 = async(start = CoroutineStart.LAZY) { 29 } //... Calculation  job3.await() */
        // Current function call stack  main  In the main thread 
        val job4 = async(context = Dispatchers.IO, start = CoroutineStart.UNDISPATCHED) {
    
            println("thread:" + Thread.currentThread().name)
        }
    }

Scope builder of the collaboration

coroutineScope And runBlocking

1.runBlocking It's a regular function , and coroutineScope It's a suspend function .
2. They all wait for the end of their coroutine body and all child coroutines , The main difference is that runBlocking Method blocks the current thread to wait , and coroutineScope Only hang , The underlying thread is freed for other purposes .

coroutineScope And supervisorScope

1.coroutineScope: A collaboration failed , All other brotherhood programs will also be cancelled .
2.supervisorScope: A collaboration failed , It won't affect other brothers' cooperation .

@Test
    fun `test coroutine scope builder`() = runBlocking {
    
        coroutineScope {
    
            //job1 Zixie Cheng 
            val job1 = launch {
    
                delay(400)
                println("job1 finished.")
            }
            //job2 Zixie Cheng 
            val job2 = async {
    
                delay(200)
                println("job2 finished.")
                "job2 result"   //async  Return value 
                //job2 Exception thrown in ,job1 and job2 Will be canceled 
                throw IllegalArgumentException()
            }

        }
    }
    @Test
    fun `test supervisor scope builder`() = runBlocking {
    
        supervisorScope {
    
            //job1 Zixie Cheng 
            val job1 = launch {
    
                delay(400)
                println("job1 finished.")
            }
            //job2 Zixie Cheng 
            val job2 = async {
    
                delay(200)
                println("job2 finished.")
                "job2 result"   //async  Return value 
                //job2 Exception thrown in , Does not affect the job1
                throw IllegalArgumentException()
            }
        }
    }