Apa itu coroutine?

Coroutine membantu mengelola tugas yang berjalan lama yang mungkin memblokir thread utama dan menyebabkan aplikasi Anda menjadi tidak responsif. Coroutine adalah pola desain konkurensi yang dapat Anda gunakan di Android untuk menyederhanakan kode yang dijalankan secara asinkron.

Seperti yang Anda lihat pada diagram di atas, di utas utama Anda, Anda hanya dapat melakukan operasi kecil. Jika Anda ingin melakukan operasi yang berjalan lama di utas utama Anda, maka aplikasi Anda mungkin macet dan lambat. Atau jika Anda membuat no. latar belakang/utas pekerja kemudian masalah kehabisan memori akan datang. Coroutine adalah jenis fungsi khusus yang dengan sengaja memberikan kontrol kepada pemanggil, tetapi tidak mengakhiri konteksnya dalam proses, melainkan mempertahankannya dalam keadaan diam.

Bagaimana cara menggunakan Coroutine?

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:x.x.x"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x"
}

• Utama: menggunakan Utas UI. Di Rx mirip dengan AndroidSchedulers.MainThread()
• Default: digunakan untuk tugas intensif CPU . Ini akan menggunakan utas sebanyak inti CPU tersedia. Karena ini adalah tugas intensif CPU, tidak ada gunanya menjalankan banyak utas, karena CPU akan sibuk. Mirip dengan Schedulers.computation() di Rx.
• IO: digunakan untuk Input/Output. Membuat permintaan ke API, akses ke DB, dll. Mirip dengan Schedulers.io() di Rx.
• Pekerjaan: Ini pada dasarnya adalah tugas yang berjalan di latar belakang, dan dapat diartikan sebagai tindakan, dengan siklus hidup yang akan dihancurkan setelah selesai.
• Untuk menjalankan berbagai operasi menggunakan pekerjaan: Job.join
• Untuk membatalkan semua pekerjaan anak: Job.cancel
• withContext: cara lain untuk menulis async di mana kita tidak perlu menulis await().

suspend fun fetchUser() = withContext(Dispatchers.IO) {
        // make network call
        // return 
}

Suspend : Seperti namanya, mereka adalah fungsi yang menangguhkan eksekusi coroutine di beberapa titik, dan kemudian melanjutkan eksekusi fungsi lagi ketika hasilnya sudah siap.

suspend fun makeNetworkRequest() {
    // fetchData is another suspend function, so 'makeNetworkRequest' is going to be `suspended`
    // until it's result becomes available, without blocking the main thread.
    val result = fetchData()
    // continues executing once the result becomes available
    show(result)
}

// fetchData is main thread safe
suspend fun fetchData(): Result { ... }

Peluncuran tidak akan memblokir utas utama, tetapi di sisi lain, eksekusi bagian kode lainnya tidak akan menunggu hasil peluncuran karena peluncuran bukanlah panggilan tunda.

fun GFG()
{
    var resultOne = "Android"
    var resultTwo = "Kotlin"
    Log.i("Launch", "Before")
    launch(Dispatchers.IO) { resultOne = function1() }
    launch(Dispatchers.IO) { resultTwo = function2() }
    Log.i("Launch", "After")
    val resultText = resultOne + resultTwo
    Log.i("Launch", resultText)
}

suspend fun function1(): String
{
    delay(1000L)
    val message = "function1"
    Log.i("Launch", message)
    return message
}

suspend fun function2(): String
{
    delay(100L)
    val message = "function2"
    Log.i("Launch", message)
    return message
}

Async juga digunakan untuk memulai coroutine, tetapi memblokir thread utama di titik masuk fungsi await() dalam program.

fun GFG
{
    Log.i("Async", "Before")
    val resultOne = Async(Dispatchers.IO) { function1() }
    val resultTwo = Async(Dispatchers.IO) { function2() }
    Log.i("Async", "After")
    val resultText = resultOne.await() + resultTwo.await()
    Log.i("Async", resultText)
}

suspend fun function1(): String
{
    delay(1000L)
    val message = "function1"
    Log.i("Async", message)
    return message
}

suspend fun function2(): String
{
    delay(100L)
    val message = "function2"
    Log.i("Async", message)
    return message
}

Manfaat menggunakan Coroutine

• Coroutine adalah Thread Ringan
• Coroutine dapat berjalan secara paralel, saling menunggu dan berkomunikasi satu sama lain
• Buat ribuan coroutine tanpa masalah memori
• Terbaik untuk aplikasi modern