Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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

 AWS SDK pour Kotlin Il est asynchrone par défaut. Le SDK pour Kotlin utilise des `suspend` fonctions pour toutes les opérations, qui sont destinées à être appelées à partir d'une coroutine. 

Pour un guide plus détaillé des coroutines, consultez la documentation [officielle de Kotlin](https://kotlinlang.org/docs/coroutines-overview.html).

## Faire des demandes simultanées
<a name="making-concurrent-requests"></a>

Le générateur de coroutine [asynchrone](https://kotlinlang.org/docs/composing-suspending-functions.html#concurrent-using-async) peut être utilisé pour lancer des requêtes simultanées lorsque vous vous souciez des résultats. `async`renvoie un [Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html), qui représente un futur léger et non bloquant qui représente la promesse de fournir un résultat ultérieurement.

Si vous ne vous souciez pas des résultats (uniquement du fait qu'une opération soit terminée), vous pouvez utiliser le générateur de coroutine de [lancement](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html). `launch`est conceptuellement similaire à. `async` La différence est que launch renvoie un [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) et ne contient aucune valeur résultante, tandis que `async` renvoie un`Deferred`.

Voici un exemple de demande simultanée adressée à Amazon S3 à l'aide de l'opération [HeadObject](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/head-object.html) pour obtenir la taille du contenu de deux clés :

```
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")

}
```

## Faire des demandes de blocage
<a name="making-clocking-requests"></a>

Pour effectuer des appels de service à partir d'un code existant qui n'utilise pas de coroutines et implémente un modèle de thread différent, vous pouvez utiliser le générateur de coroutine [RunBlocking](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html). L' executors/futures approche traditionnelle de Java est un exemple de modèle de threading différent. Vous devrez peut-être utiliser cette approche si vous mélangez du code ou des bibliothèques Java et Kotlin. 

Comme son nom l'indique, ce `runBlocking` générateur lance une nouvelle coroutine et bloque le thread en cours jusqu'à ce qu'il soit terminé. 

**Avertissement**  
 `runBlocking`ne doit généralement pas être utilisé à partir d'une coroutine. Il est conçu pour relier le code de blocage normal aux bibliothèques écrites dans un style suspendu (comme dans les fonctions principales et les tests).