Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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

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

## Realización de solicitudes simultáneas
<a name="making-concurrent-requests"></a>

El generador de corrutinas [asíncronas](https://kotlinlang.org/docs/composing-suspending-functions.html#concurrent-using-async) se puede utilizar para lanzar solicitudes simultáneas cuando le interesen los resultados. `async`devuelve un [Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html), 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](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html). `launch`es conceptualmente similar a. `async` La diferencia es que launch devuelve un [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) y no contiene ningún valor resultante, mientras que `async` devuelve un`Deferred`.

El siguiente es un ejemplo de cómo realizar solicitudes simultáneas a Amazon S3 mediante la operación [headObject](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/head-object.html) 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
<a name="making-clocking-requests"></a>

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](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html). 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. 

**aviso**  
 `runBlocking`por lo general, no debe usarse desde una corrutina. Está diseñado para vincular el código de bloqueo normal con las bibliotecas que están escritas en forma suspensiva (por ejemplo, en las funciones principales y las pruebas).