Bermain dengan Coroutine Part 1

Photo by eleonora on Unsplash

Overview

asyncronous atau non-blocking programming merupakan bagian yang penting dalam pengembangan aplikasi. ketika membuat server-side, desktop, atau mobile app, penting untuk menyajikan pengalaman yang tidak hanya menyasar ke user perspektif juga untuk skala besar ketika dibutuhkan

kotlin memecahkan masalah dengan cara fleksibel dengan menyediakan coroutine didukung dalam level bahasa pemograman dan didelegasikan di banyak fungsi dan librari, mari kita bahas dalam pengembangan aplikasi android

Apa itu Coroutine?

coroutine merupakan asyncronous atau non-blocking programming yang dibuat untuk bahasa pemograman kotlin, coroutine juga concurrency design patern yang digunakan untuk mempersingkat kode yang dieksekusi secara asinkron.

dalam android, coroutine berguna untuk mengelola tugas yang berjalan lama yang mungkin bisa memblokir main thread dan menyebabkan aplikasi menjadi tidak responsive.

Concurrency
ialah kemampuan suatu program untuk menangani multiple order atau request. Dimana setiap order atau request yang masuk bisa ditumpuk / dibebani oleh satu proses

Syncronous
adalah proses jalannya program secara sequential , disini yang dimaksud sequential ada berdasarkan antrian ekseskusi program. Pada dasarnya semua Bahasa pemrograman menggunakan Syncronous

Asyncronous
adalah proses jalannya program bisa dilakukan secara bersamaan tanpa harus menunggu proses antrian. Synchronous merupakan bagian dari Asynchronous (1 antrian) dimana proses akan dieksekusi secara bersamaan dan untuk hasil tergantung lama proses suatu fungsi synchronous, karena fungsi yang lain dapat berjalan tanpa harus menunggu fungsi ini selesai

Fitur

coroutine memiliki banyak fitur sehingga sangat direkomendasikan untuk pemograman asinkron di Android

• Lightweight beberapa coroutine dapat di jalankan dalam satu thread, karena kotlin mendukung susspension contoh kita bisa menahan suatu fungsi nutuk mengeksekusi dan melanjutkan fungsi yang lain
• Fewer memory leaks menggunakan structured concurrency. Artinya coroutine yang baru, hanya dapat dijalankan dalam cakupan coroutinescope hal ini dapat membatasi coroutine Dalam pengaplikasiannya, biasanya kita membuat beberapa coroutine.
• Built-in cancellation support otomatis dijalankan ketika berada dalam coroutine yang sedang berjalan, dapat menjalankan cancel dengan beberapa mekanisme
• Jetpack integration Banyak library jetpack yang sudah memiliki ekstensi coroutine dengan dukungan penuh. Beberapa library juga menyediakan coroutine scope sendiri yang dapat Anda gunakan untuk membuat struktur serentak.

Bagaimana Cara Kerja Coroutine?

coroutine memiliki banyak jenis, tetapi memiliki cara kerja yang sama dimana ketika di jalankan coroutine harus ada di dalam coroutineScope, untuk menjalankan sebuah fungsi di dalam coroutine di butuhkan suspend function jadi setiap fungsi berjalan secara konkuren

import kotlinx.coroutines.*
fun main() = runBlocking { // this: CoroutineScope
    launch { // launch a new coroutine and continue
        delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
        println("World!") // print after delay
    }
    println("Hello") // main coroutine continues while a previous one is delayed
}
Hello
World!

Mari kita bedah apa saja isi kode di atas

• Launch ⇒ Merupakan coroutine builder, builder ini meluncurkan coroutine baru, bekerja secara independen. itulah mengapa Hello di print pertama kali
• delay ⇒ Merupakan supending function. fungsi ini menahan coroutine untuk waktu yang telah di tentukan, delay tidak memblok thread yang sedang berjalan tetapi mengizinkan coroutine lain untuk berjalan terlebih dahulu dan menggunakan thread yang sedang berjalan
• runBlocking ⇒ juga merupakan coroutine builder yang menjembatani non-corutine dengan regular fun main dan kode dengan coroutine dimasukan di dalam di dalam kurung kurawal runblocking{}, runblocking ini berjalan di mainThread, jadi ketika di jalankan akan memblock main thread, biasanya UI thread identik dengan main thread

Apa yang dimaksud dengan CoroutineScope?

merupakan blok cakupan untuk menampung berbagai jenis coroutine, kita juga bisa mengatur untuk memulai atau menstop coroutine

Lifecyle pada coroutine

pada coroutine mendukung beberapa lifecyle seperti GlobalScope, lifecycleScope, viewmodelScope

• Globalscope
  merupakan coroutine yang berada di top level aplikasi mencakup global aplikasi, ketika coroutine ini di jalankan maka coroutine ini akan tetap berjalan selama aplikasi terbuka

• LifecylceScope
  merupakan coroutine yang berada di level activity, ketika lifecyle dari activity masih berjalan maka coroutine ini tetap berjalan

• viewModelScope
  berjalan pada lifecyleviewmodel lifecyle

viewmodel lifecyle

untuk scope ini akan di bahas di sesi lain

Dispatchers
merupakan objek penentu thread mana yang akan di gunakan untuk menjalankan coroutine

• Dispatchers.Default: CPU-intensive work, digunakan ketika operasi berhubungan dengan list daftar skala besar, melakukan perhitungan rumit dan sejenisnya.
• Dispatchers.IO: digunakan untuk networking atau membaca dan menulis dari file . singkatnya untuk input dan output
• Dispatchers.Unconfined Dispatcher ini tidak terbatas pada thread tertentu. Dengan kata ain, Dispatcher.unconfined cocok Untuk coroutine yang tidak menghabiskan waktu CPU atau memperbarui data bersama (seperti UI) yang dibatasi Pada thread Tertentu.
• Dispatchers.Main: digunakan ketika melakukan operasi yang berhubungan dengan main thread, misal ketika mengupdate tampilan diperlukan
  note: jangan melakukan operasi yang intensif karena akan memblokir ui thread dan menyebabkan aplikasi tidak responsif

Mari kita coba semua dispatcher diatas, dengan menjalankan kode di bawah

GlobalScope.launch {
    delay(1000L)
    launch(Dispatchers.Main) {
        Log.d("multipleLaunches", "Running In ${Thread.currentThread().name}")
    }
    delay(1000L)
    launch(Dispatchers.IO) {
        Log.d("multipleLaunches", "Running In ${Thread.currentThread().name}")
    }
    delay(1000L)
    launch(Dispatchers.Default) {
        Log.d("multipleLaunches", "Running In ${Thread.currentThread().name}")
    }
    delay(1000L)
    launch(Dispatchers.Unconfined) {
        Log.d("multipleLaunches", "Running In ${Thread.currentThread().name}")
    }
}

Menarik Bukan? sebenarnya masih banyak dari coroutine yang sangat menarik tapi akan di lanjutkan di lain kesempatan

Kesimpulan
coroutine merupakan fitur yang sangat berguna untuk menjawab permasalahan mengenai asinkron programming dalam kotlin, selain itu coroutine sangat mudah di implementasikan serta ringan. dalam pengembangan aplikasi coroutine akan banyak sekali di gunakan, kita dapat menggunakan thread apa yang kita butuhkan membuat aplikasi lebih responsif.

If you do what you love, determination and consistency will come naturally — Mosh Hamedani

Sumber
https://saketh001.hashnode.dev/ultimate-kotlin-coroutines-cheat-sheet
https://kt.academy/article/cc-builders
https://kotlinlang.org/docs/multiplatform-mobile-concurrency-and-coroutines.html#multithreaded-coroutines
https://developer.android.com/kotlin/coroutines