Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Coroutinen
<a name="coroutines"></a>

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.](https://kotlinlang.org/docs/coroutines-overview.html)

## Gleichzeitige Anfragen stellen
<a name="making-concurrent-requests"></a>

Der [asynchrone](https://kotlinlang.org/docs/composing-suspending-functions.html#concurrent-using-async) Coroutine Builder kann verwendet werden, um gleichzeitige Anfragen zu starten, bei denen Ihnen die Ergebnisse wichtig sind. `async`gibt einen Wert vom Typ [Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html) 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.](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html) `launch`ist konzeptionell ähnlich wie. `async` Der Unterschied besteht darin, dass launch einen [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) zurückgibt und keinen Ergebniswert enthält, während launch a `async` zurückgibt`Deferred`.

Im Folgenden finden Sie ein Beispiel für gleichzeitige Anfragen an Amazon S3 mithilfe der Operation [headObject](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/head-object.html), 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
<a name="making-clocking-requests"></a>

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](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) verwenden. Ein Beispiel für ein anderes Threading-Modell ist die Verwendung des traditionellen Ansatzes von Java. executors/futures Möglicherweise müssen Sie diesen Ansatz verwenden, wenn Sie Java- und Kotlin-Code oder -Bibliotheken mischen. 

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

**Warnung**  
 `runBlocking`sollte im Allgemeinen nicht von einer Coroutine aus verwendet werden. Es wurde entwickelt, um regulären Blockierungscode mit Bibliotheken zu verbinden, die im Suspending-Stil geschrieben sind (z. B. in Hauptfunktionen und Tests).