Coroutinen

Der AWS SDK für Kotlin ist standardmäßig asynchron. Das SDK für Kotlin verwendet suspend Funktionen für alle Operationen, die dazu bestimmt sind, von einer Coroutine aus aufgerufen zu werden.

Eine ausführlichere Anleitung zu Coroutinen finden Sie in der offiziellen Kotlin-Dokumentation.

Gleichzeitige Anfragen stellen

Der asynchrone Coroutine Builder kann verwendet werden, um gleichzeitige Anfragen zu starten, bei denen Ihnen die Ergebnisse wichtig sind. asyncgibt einen Wert vom Typ Deferred zurück, was für eine leichtgewichtige, nicht blockierende future steht, die ein Versprechen darstellt, zu einem späteren Zeitpunkt ein Ergebnis zu liefern.

Wenn Ihnen die Ergebnisse egal sind (nur, dass ein Vorgang abgeschlossen wurde), können Sie den Launch Coroutine Builder verwenden. launchist konzeptionell ähnlich wie. async Der Unterschied besteht darin, dass launch einen Job zurückgibt und keinen Ergebniswert enthält, während launch a async zurückgibtDeferred.

Im Folgenden finden Sie ein Beispiel für gleichzeitige Anfragen an Amazon S3 mithilfe der Operation headObject, um die Inhaltsgröße von zwei Schlüsseln abzurufen:

import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking
import kotlin.system.measureTimeMillis
import aws.sdk.kotlin.services.s3.S3Client


fun main(): Unit = runBlocking {

    val s3 = S3Client { region = "us-east-2" }
    
    val myBucket = "<your-bucket-name-here>"
    val key1 = "<your-object-key-here>"
    val key2 = "<your-second-object-key-here>"

    val resp1 = async {
        s3.headObject{
            bucket = myBucket
            key = key1
        }
    }

    val resp2 = async {
        s3.headObject{
            bucket = myBucket
            key = key2
        }
    }


    val elapsed = measureTimeMillis {
        val totalContentSize = resp1.await().contentLength + resp2.await().contentLength
        println("content length of $key1 + $key2 = $totalContentSize")
    }

    println("requests completed in $elapsed ms")

}

Blockierungsanfragen stellen

Um Serviceaufrufe von vorhandenem Code aus zu tätigen, der keine Coroutinen verwendet und ein anderes Threading-Modell implementiert, können Sie den RunBlocking-Coroutine-Builder verwenden. Ein Beispiel für ein anderes Threading-Modell ist die Verwendung des traditionellen Executors/Futures-Ansatzes von Java. Möglicherweise müssen Sie diesen Ansatz verwenden, wenn Sie Java- und Kotlin-Code oder -Bibliotheken kombinieren.

Wie der Name schon sagt, startet dieser runBlocking Builder eine neue Coroutine und blockiert den aktuellen Thread, bis er abgeschlossen ist.