Coroutinecontext in kotlin

---

The context of the coroutine

CoroutineContext Is a set of elements that define the behavior of a coroutine . It consists of the following ：

• 1.Job: Control the lifecycle of the process .
• 2.CoroutineDispatcher: Distribute tasks to the appropriate threads .
• 3.CoroutineName: The name of the program , It's useful when debugging .
• 4.CoroutineExceptionHandle: Handling uncapped exceptions .

Combine elements in context

Sometimes we need to define multiple elements in the context of a collaboration . We can use + Operator to implement . for instance , We can specify a scheduler to start the process and specify a name at the same time ：

@Test
    fun `test CoroutineContext`() = runBlocking<Unit> {
    
        launch(Dispatchers.Default + CoroutineName("test")) {
    
            println("I'm working in thread${
      Thread.currentThread().name}")
        }
    }

Inheritance of coroutine context

• For the newly created collaboration , its CoroutineContext Will include a new Job example , It will help us to control the lifecycle of the coprocessor . And the rest of the elements go from CoroutineContext Inherits from the parent class of , The parent class may be another coroutine or the one that created it CoroutineScope

 @Test
    fun `test CoroutineContext extend`() = runBlocking<Unit> {
    
        val scope = CoroutineScope(Job() + Dispatchers.IO + CoroutineName("test"))
        val job = scope.launch {
    
            // The new program will CoroutineScope As a parent 
            println("${
      coroutineContext[Job]} ${
      Thread.currentThread().name}")
            val result = async {
    
                // adopt async The new coroutine created will take the current coroutine as a parent 
                println("${
      coroutineContext[Job]} ${
      Thread.currentThread().name}")
                "OK"
            }.await()
        }
        job.join()
        /** "test#2":StandaloneCoroutine{Active}@11443e84 DefaultDispatcher-worker-1 @test#2 "test#3":DeferredCoroutine{Active}@2cf1f044 DefaultDispatcher-worker-3 @test#3 */
    }

The context of the coroutine = The default value is + inherited CoroutineContext + Parameters

• Some elements contain default values ：Dispatchers.Default By default CoroutineDispatcher, as well as “coroutine” By default CoroutineName;
• inherited CoroutineContext yes CoroutineScope Or his father's CoroutineContext;
• Parameters passed into the collaboration builder take precedence over inherited context parameters , Therefore, the corresponding parameter value will be overridden .
• The ultimate parent CoroutineContext It will contain Dispatchers.IO instead of scope In the object Dispatcher.Main, Because it is overwritten by the parameters in the constructor of the collaboration . Besides , Pay attention to the parent CoroutineContext Inside Job yes scope Object's Job（ Red ）, And new Job example ( green ) Will be assigned to a new coroutine CoroutineContext.
  

@Test
    fun `test CoroutineContext extend2`() = runBlocking<Unit> {
    
        val coroutineExceptionHandler = CoroutineExceptionHandler {
     _, exception ->
            println("Caught $exception")
        }
        val scope = CoroutineScope(Job() + Dispatchers.Main + coroutineExceptionHandler)
        // new CoroutioneContext =  Parent CoroutineContext + Job()
        val job = scope.launch(Dispatchers.IO) {
    
            // New association 
        }
    }