Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Coroutine


Per impostazione predefinita, AWS SDK per Kotlin è asincrono. L'SDK per Kotlin utilizza `suspend` funzioni per tutte le operazioni, che devono essere chiamate da una coroutine. 

[Per una guida più approfondita alle coroutine, consulta la documentazione ufficiale di Kotlin.](https://kotlinlang.org/docs/coroutines-overview.html)

## Effettuare richieste simultanee


Il generatore di coroutine [asincrono](https://kotlinlang.org/docs/composing-suspending-functions.html#concurrent-using-async) può essere utilizzato per avviare richieste simultanee in cui si tengono i risultati. `async`restituisce un [Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html), che rappresenta un futuro leggero e non bloccante che rappresenta la promessa di fornire un risultato in un secondo momento.

[Se non ti interessano i risultati (solo che un'operazione è stata completata), puoi utilizzare Launch Coroutine Builder.](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html) `launch`è concettualmente simile a. `async` La differenza è che launch restituisce un [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) e non contiene alcun valore risultante, mentre `async` restituisce un`Deferred`.

Di seguito è riportato un esempio di richiesta simultanea ad Amazon S3 utilizzando [l'operazione headObject per ottenere la](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/head-object.html) dimensione del contenuto di due chiavi:

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

}
```

## Effettuare richieste di blocco


[Per effettuare chiamate di servizio da codice esistente che non utilizza coroutine e implementa un modello di threading diverso, puoi utilizzare il generatore di coroutine RunBlocking.](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) Un esempio di modello di threading diverso è l'utilizzo dell'approccio tradizionale di Java. executors/futures Potrebbe essere necessario utilizzare questo approccio se state combinando codice o librerie Java e Kotlin. 

Come suggerisce il nome, questo `runBlocking` builder lancia una nuova coroutine e blocca il thread corrente fino al suo completamento. 

**avvertimento**  
 `runBlocking`generalmente non dovrebbe essere usato da una coroutine. È progettato per collegare il normale codice di blocco a librerie scritte in stile suspending (come nelle funzioni e nei test principali).