Corrutinas

AWS SDK para Kotlin Es asíncrono de forma predeterminada. El SDK para Kotlin usa suspend funciones para todas las operaciones, que deben invocarse desde una corrutina.

Para obtener una guía más detallada sobre las corrutinas, consulta la documentación oficial de Kotlin.

Realización de solicitudes simultáneas

El generador de corrutinas asíncronas se puede utilizar para lanzar solicitudes simultáneas cuando le interesen los resultados. asyncdevuelve un Deferred, que representa un futuro ligero y sin bloqueos que representa la promesa de ofrecer un resultado más adelante.

Si no te importan los resultados (solo que se haya completado una operación), puedes usar el generador de corrutinas de lanzamiento. launches conceptualmente similar a. async La diferencia es que launch devuelve un Job y no contiene ningún valor resultante, mientras que async devuelve unDeferred.

El siguiente es un ejemplo de cómo realizar solicitudes simultáneas a Amazon S3 mediante la operación headObject para obtener el tamaño del contenido de dos claves:

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

}

Realizar solicitudes de bloqueo

Para realizar llamadas de servicio desde el código existente que no usa corrutinas e implementa un modelo de subprocesos diferente, puedes usar el generador de corrutinas RunBlocking. Un ejemplo de un modelo de subprocesamiento diferente es el uso del enfoque tradicional de Java. executors/futures Es posible que necesites usar este enfoque si vas a combinar código o bibliotecas de Java y Kotlin.

Como su nombre indica, este runBlocking generador lanza una nueva corrutina y bloquea el hilo actual hasta que se complete.