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.

Effettuare richieste simultanee

Il generatore di coroutine asincrono può essere utilizzato per avviare richieste simultanee in cui si tengono i risultati. asyncrestituisce un Deferred, 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. launchè concettualmente simile a. async La differenza è che launch restituisce un Job e non contiene alcun valore risultante, mentre async restituisce unDeferred.

Di seguito è riportato un esempio di richiesta simultanea ad Amazon S3 utilizzando l'operazione headObject per ottenere la 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. Un esempio di modello di threading diverso è l'utilizzo del tradizionale approccio executors/futures di Java. 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.