Kotlin middle process understanding and Practice (II)

---

Coroutine builder

One .launch And async Builders are used to start new processes

1.launch, Return to one Job And without any result value .
2.async, Return to one Deferred, Deferred Also a Job, have access to .await() Get its final result on a delayed value .

Two , Waiting for a job

1.join And await
2. Combined concurrency

 /**  Use  runBlocking  Wrap the main thread as a coroutine   Top collaboration  GlobalScope, The life cycle is process Grade , Even if Activity perhaps Fragment Has been destroyed , The collaboration process is still being implemented . */

    // join And await
    @Test
    fun `test coroutine builder`() = runBlocking {
    
        //job1 Zixie Cheng 
        val job1 = launch {
    
            delay(200)
            println("job1 finished.")
        }
        //job2 Zixie Cheng 
        val job2 = async {
    
            delay(200)
            println("job2 finished.")
            "job2 result"   //async  Return value 
        }
        println(job2.await())
        /** job1 finished. job2 finished. job2 result */
    }


    @Test
    fun `test coroutine join`() = runBlocking {
    
        //job1 Zixie Cheng 
        val job1 = launch {
    
            delay(2000)
            println("One")
        }
        job1.join()  // Execute first job1 coroutines , Re execution job2,job3 coroutines 
        //job2 Zixie Cheng 
        val job2 = launch {
    
            delay(200)
            println("Two")
        }
        //job3 Zixie Cheng 
        val job3 = launch {
    
            delay(200)
            println("Three")
        }
        /** One Two Three */
    }

    @Test
    fun `test coroutine await`() = runBlocking {
    
        //job1 Zixie Cheng 
        val job1 = async {
    
            delay(2000)
            println("One")
        }
        job1.await()  // Execute first job1 coroutines , Re execution job2,job3 coroutines 
        //job2 Zixie Cheng 
        val job2 = async {
    
            delay(200)
            println("Two")
        }
        //job3 Zixie Cheng 
        val job3 = async {
    
            delay(200)
            println("Three")
        }
        /** One Two Three */
    }

    // Combined concurrency 
    @Test
    fun `test sync`() = runBlocking {
    
        val time = measureTimeMillis {
    
            val one = doOne()
            val two = doTwo()
            println("The result:${
      one + two}")
        }
        println("Completed in $time ms")
        /** The result:26 Completed in 2020 ms */
    }

    @Test
    fun `test combine async`() = runBlocking {
    
        val time = measureTimeMillis {
    
            val one = async {
     doOne() }
            val two = async {
     doTwo() }
            println("The result:${
      one.await() + two.await()}")
// val one = async { doOne() }.await()
// val two = async { doTwo() }.await()
// println("The result:${one + two}") //Completed in 2020 ms
        }
        println("Completed in $time ms")
        /** The result:26 Completed in 1020 ms */
    }

    private suspend fun doOne(): Int {
    
        delay(1000)
        return 14
    }

    private suspend fun doTwo(): Int {
    
        delay(1000)
        return 12
    }