Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

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

 AWS SDK untuk Kotlin Ini asinkron secara default. SDK untuk Kotlin menggunakan `suspend` fungsi untuk semua operasi, yang dimaksudkan untuk dipanggil dari coroutine. 

Untuk panduan lebih mendalam tentang coroutine, lihat dokumentasi [resmi](https://kotlinlang.org/docs/coroutines-overview.html) Kotlin.

## Membuat permintaan bersamaan
<a name="making-concurrent-requests"></a>

Pembuat coroutine [async](https://kotlinlang.org/docs/composing-suspending-functions.html#concurrent-using-async) dapat digunakan untuk meluncurkan permintaan bersamaan di mana Anda peduli dengan hasilnya. `async`mengembalikan [Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html), yang mewakili masa depan yang ringan dan tidak memblokir yang mewakili janji untuk memberikan hasil nanti.

Jika Anda tidak peduli dengan hasilnya (hanya bahwa operasi selesai), Anda dapat menggunakan pembuat coroutine [peluncuran](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html). `launch`secara konseptual mirip dengan. `async` Perbedaannya adalah peluncuran mengembalikan [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) dan tidak membawa nilai apa pun yang dihasilkan, sementara `async` mengembalikan a`Deferred`.

[Berikut ini adalah contoh membuat permintaan bersamaan ke Amazon S3 menggunakan operasi HeadObject untuk mendapatkan ukuran konten dari dua kunci:](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/head-object.html)

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

}
```

## Membuat permintaan pemblokiran
<a name="making-clocking-requests"></a>

[Untuk melakukan panggilan layanan dari kode yang ada yang tidak menggunakan coroutine dan mengimplementasikan model threading yang berbeda, Anda dapat menggunakan pembuat coroutine RunBlocking.](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) Contoh model threading yang berbeda menggunakan executors/futures pendekatan tradisional Java. Anda mungkin perlu menggunakan pendekatan ini jika Anda memadukan kode atau pustaka Java dan Kotlin. 

Seperti namanya, `runBlocking` pembuat ini meluncurkan coroutine baru dan memblokir utas saat ini hingga selesai. 

**Awas**  
 `runBlocking`umumnya tidak boleh digunakan dari coroutine. Ini dirancang untuk menjembatani kode pemblokiran reguler ke perpustakaan yang ditulis dalam gaya penangguhan (seperti dalam fungsi utama dan tes).