As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

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

O AWS SDK para Kotlin é assíncrono por padrão. O SDK para Kotlin usa `suspend` funções para todas as operações, que devem ser chamadas a partir de uma corrotina. 

Para obter um guia mais detalhado sobre corrotinas, consulte a documentação [oficial](https://kotlinlang.org/docs/coroutines-overview.html) do Kotlin.

## Fazendo solicitações simultâneas
<a name="making-concurrent-requests"></a>

O construtor de corrotinas [assíncronas](https://kotlinlang.org/docs/composing-suspending-functions.html#concurrent-using-async) pode ser usado para iniciar solicitações simultâneas nas quais você se preocupa com os resultados. `async`retorna um [Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html), que representa um future leve e sem bloqueios que representa a promessa de fornecer um resultado posteriormente.

Se você não se importa com os resultados (apenas com a conclusão de uma operação), você pode usar o construtor de corrotinas de [inicialização](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html). `launch`é conceitualmente semelhante a. `async` A diferença é que o launch retorna um [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) e não carrega nenhum valor resultante, enquanto `async` retorna `Deferred` a.

Veja a seguir um exemplo de como fazer solicitações simultâneas para o Amazon S3 usando a operação HeadObject para obter [o](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/head-object.html) tamanho do conteúdo de duas chaves:

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

}
```

## Fazendo solicitações de bloqueio
<a name="making-clocking-requests"></a>

[Para fazer chamadas de serviço a partir de código existente que não usa corrotinas e implementa um modelo de encadeamento diferente, você pode usar o construtor de corrotinas RunBlocking.](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) Um exemplo de um modelo de segmentação diferente é usar a executors/futures abordagem tradicional do Java. Talvez seja necessário usar essa abordagem se estiver combinando código ou bibliotecas Java e Kotlin. 

Como o próprio nome sugere, esse `runBlocking` construtor lança uma nova corrotina e bloqueia o encadeamento atual até que ele seja concluído. 

**Atenção**  
 `runBlocking`geralmente não deve ser usado a partir de uma corrotina. Ele foi projetado para conectar o código de bloqueio regular às bibliotecas escritas em estilo suspenso (como nas funções e testes principais).