当前位置：网站首页>Introduction to kotlin collaboration

Introduction to kotlin collaboration

2022-07-03 01:40:00 【AnRFDev】

development environment

IntelliJ IDEA 2021.2.2 (Community Edition)
Kotlin: 212-1.5.10-release-IJ5284.40

Introduce Kotlin Association in . Use an example to show the basic usage of coprocessing .

First example

New project

We use the community version IntelliJ IDEA 2021.2.2. Create a new one Kotlin Engineering is used to test .

Kotlin Introduction to coroutines _ide

Lead in process

The project with gradle Conduct management , We are Github Find the dependency of the synergy on .

       
        dependencies {
        
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2")
        
}
       
       
        1.
        2.
        3.

Project modification gradle To configure . Add dependencies .

Kotlin Introduction to coroutines _ The main thread _02

Code example

Create a class and then main Method to write the relevant code of the coroutine .

       
        import kotlinx.coroutines.GlobalScope
        
import kotlinx.coroutines.delay
        
import kotlinx.coroutines.launch
        

        
fun main() {
        
    GlobalScope.launch { //  Start a new process in the background and continue 
        
        delay(300)       //  wait for 300 millisecond 
        
        "rustfisher.com".forEach {
        
            print(it)
        
            delay(200)   //  Wait every time you print 
        
        }
        
    }
        
    println("RustFisher")
        
    Thread.sleep(3000) //  Blocking the main thread prevents too fast exit 
        
}
       
       
        1.
        2.
        3.
        4.
        5.
        6.
        7.
        8.
        9.
        10.
        11.
        12.
        13.
        14.
        15.

Code run results

Kotlin Introduction to coroutines _fish_03

Essentially , A coroutine is a lightweight thread .

We use it GlobalScope Started a new collaborative process , This means that the life cycle of the new collaboration is limited only by the life cycle of the entire application .

Can be GlobalScope.launch { …… } Replace with thread { …… }, And will delay(……) Replace with Thread.sleep(……) Achieve the same purpose . Pay attention to the import package kotlin.concurrent.thread

Replace a coroutine with a thread

       
        import java.lang.Thread.sleep
        
    import kotlin.concurrent.thread
        

        
    fun main() {
        
        thread {
        
            sleep(300)
        
            "rustfisher.com".forEach {
        
                print(it)
        
                sleep(200)
        
            }
        
        }
        
        println("RustFisher")
        
        sleep(3000) //  Blocking the main thread prevents too fast exit 
        
    }
       
       
        1.
        2.
        3.
        4.
        5.
        6.
        7.
        8.
        9.
        10.
        11.
        12.
        13.
        14.

If thread{} contains delay, The compiler will report an error

Suspend function 'delay' should be called only from a coroutine or another suspend function

because delay It's a special one Suspend function , It doesn't block threads , But will Hang up coroutines , And it can only be used in the cooperation process .

thus , To summarize the first collaborative process example

gradle Lead in process kotlinx-coroutines-core
GlobalScope.launch Start the coroutines
In the process of cooperation Hang up function delay(long) It can achieve the effect of delay , And it can only be used in collaboration

The thread where the coroutine is located

Essentially, a coroutine is a lightweight thread . Let's look at the thread information where the coroutine is located .

       
        import kotlinx.coroutines.GlobalScope
        
    import kotlinx.coroutines.launch
        
    import java.lang.Thread.sleep
        

        
    fun main() {
        
        println("main Thread information  ${Thread.currentThread().id}")
        
        for (i in 1..3) { //  Start the process several times 
        
            GlobalScope.launch {
        
                println(" Start the process #$i  Thread id: ${Thread.currentThread().id}")
        
            }
        
        }
        
        sleep(2000) //  Blocking the main thread prevents too fast exit 
        
        println("RustFisher  The example ends ")
        
    }
       
       
        1.
        2.
        3.
        4.
        5.
        6.
        7.
        8.
        9.
        10.
        11.
        12.
        13.
        14.

function log as follows

       
        main Thread information  1
        
    Start the process #1  Thread id: 11
        
    Start the process #3  Thread id: 14
        
    Start the process #2  Thread id: 13
        
   RustFisher  The example ends 
       
       
        1.
        2.
        3.
        4.
        5.

You can see that the process is started many times , These coroutines are not necessarily in the same thread . In other words, there are Same thread The possibility of .

So try to start the process crazily , Increase the number of cycles for (i in 1..3000). Observe log It can be seen that , There are duplicate threads id.

Kotlin Introduction to coroutines _fish_04