[Kotlin] Async und Wait-Nutzung für gleichzeitige Coroutine-Operationen

Überblick

Bevor ich über die Verwendung der gleichzeitigen Coroutine-Operationen Async und Wait spreche, möchte ich zunächst die Definition von Coroutine erwähnen: Coroutine ist ein leichter gleichzeitiger Programmiermechanismus, der auf der Grundlage der Suspend-Funktion implementiert wird und die Coroutine anhalten kann, wenn die Funktion ausgeführt wird. Der nachfolgende Code innerhalb des Blocks wird ausgeführt, nachdem die asynchrone Aufgabenausführung abgeschlossen ist. Asynchrone Aufgaben werden synchron abgearbeitet.

asynchron, warte auf die Analyse des Quellcodes

Die asynchrone Methode gibt einen Deferred zurück, der eine Unterklasse von Job ist. Der asynchrone Quellcode lautet wie folgt:

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T> {
    
    
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyDeferredCoroutine(newContext, block) else
        DeferredCoroutine<T>(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

wait ist eine Methode der Deferred-Schnittstelle:

public interface Deferred<out T> : Job {
    
    

    public suspend fun await(): T

    public val onAwait: SelectClause1<T>

    @ExperimentalCoroutinesApi
    public fun getCompleted(): T

    @ExperimentalCoroutinesApi
    public fun getCompletionExceptionOrNull(): Throwable?
}

Anwendungsbeispiele und Prozessanalyse

package com.techme.jetpack

import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
///协程之并发操作
fun main() {
    
    
    GlobalScope.launch {
    
    
        //2.进入协程块，开始running
        println("GlobalScope.launch is running:${
      
      System.currentTimeMillis()}")
        val result1 = request1()
        //4.result1 执行结束
        println("$result1:${
      
      System.currentTimeMillis()}")
        val deferred2 = async {
    
     request2() }
        val deferred3 = async {
    
     request3() }
        // 7.request2和request3并发执行结束,更新ui。
        println("update UI ${
      
      deferred2.await()},${
      
      deferred3.await()}:${
      
      System.currentTimeMillis()}")
    }
    //1.先执行主线程的任务
    println("main Thread:${
      
      System.currentTimeMillis()}")
    Thread.sleep(6000)//主线程休眠6000（即协程内挂起函数休眠的总和），为了确保协程内的任务执行完。
}

suspend fun request3(): String {
    
    
    //6.call request3
    println("call request3:${
      
      System.currentTimeMillis()}")
    delay(3000)
    return "result3"
}

suspend fun request2(): String {
    
    
    //5.call request2
    println("call request2:${
      
      System.currentTimeMillis()}")
    delay(2000)
    return "result2"
}

suspend fun request1(): String {
    
    
    //3.call request1
    println("call request1:${
      
      System.currentTimeMillis()}")
    delay(1000)
    return "result1"
}

Führen Sie die Druckergebnisse aus:

main Thread:1701915880220 //1.先执行主线的任务
GlobalScope.launch is running:1701915880235 //2.进入协程块，开始running
call request1:1701915880237//3.call request1
result1:1701915881269//4.result1请求结果，result1 执行的时间 1701915881269-1701915880237=1032
call request2:1701915881276//5.call request2
call request3:1701915881289//6.call request3
update UI result2,result3:1701915884303//7.request2和request3并发执行结束。request2执行时间：1701915884303-1701915881276=3027  request3执行时间：1701915884303-1701915881289=3014，request2和request3总的执行时间差不多3000，若是串行的话request2和request3的总执行时间应该差不多5000，因此属于并发执行，增强了任务间协同。

Process finished with exit code 0//8.结束

Zusammenfassung

async startet eine neue Coroutine, gibt ein Deferred-Objekt zurück und ruft das Ergebnis der Coroutine-Ausführung über die Wait-Methode von Deferred ab.

Im Vergleich zum herkömmlichen Thread-Mechanismus bieten Coroutinen folgende Vorteile:

1. Leichter: Die Erstellung und Zerstörung von Coroutinen ist einfacher als die von Threads und kann Systemressourcen effizienter nutzen.
2. Flexibler: Der Ausführungsprozess der Coroutine kann angehalten und wieder aufgenommen werden, was die Handhabung asynchroner Aufgaben erleichtert.
3. Sicherer: Coroutinen vermeiden Probleme wie Thread-Race-Bedingungen und Deadlocks und ermöglichen so eine sicherere gleichzeitige Programmierung.