Apa itu Coroutine di Kotlin?

Coroutine adalah fitur hebat yang tersedia dalam bahasa Kotlin. Saya sudah mencobanya dan saya sangat menyukainya.

Tujuan artikel ini adalah untuk membantu Anda memahami Corutins. Berhati-hatilah saat membaca dan Anda akan berhasil.

Mari kita mulai dengan definisi resmi Corutin.

Coroutine adalah cara baru untuk menulis kode yang tidak sinkron dan tidak sinkron.

Pertanyaan pertama yang muncul ketika membaca definisi ini adalah bagaimana perbedaan Coroutine dari aliran?

Coroutine adalah aliran yang ringan. Thread yang ringan berarti tidak diikat ke thread asli, oleh karena itu tidak memerlukan pengalihan konteks ke prosesor, oleh karena itu lebih cepat.

Apa artinya, "tidak dilampirkan ke utas asli" ?

Coroutine ditemukan dalam banyak bahasa pemrograman.

Pada dasarnya, ada dua jenis Corutin:

• menggunakan tumpukan;
• tumpukan tidak digunakan;

Kotlin mengimplementasikan Coroutine tanpa tumpukan - ini berarti bahwa Coroutine tidak memiliki tumpukan mereka sendiri, sehingga mereka tidak terikat pada utas asli.

Baik Coroutine dan stream multitasking. Tetapi perbedaannya adalah bahwa utas dikendalikan oleh OS, dan Coroutine adalah oleh pengguna.

Sekarang Anda dapat secara sadar membaca dan memahami kutipan dari situs web resmi Kotlin:

Coroutine dapat direpresentasikan dalam bentuk aliran yang difasilitasi. Seperti utas, coroutine dapat bekerja secara paralel, saling menunggu dan berkomunikasi. Perbedaan terbesar adalah coroutine sangat murah, hampir gratis: kita dapat membuatnya dalam ribuan dan membayar sangat sedikit dalam hal kinerja. Streaming itu mahal. Seribu benang dapat menjadi masalah serius bahkan untuk mesin modern.

Mari kita lihat bagaimana cara bekerja dengan Coroutine

Jadi, bagaimana cara memulai coroutine (mirip dengan memulai utas)?

Ada dua fungsi untuk meluncurkan coroutine:

• launch{}
• async{}

luncurkan {} vs async {} di Kotlin Coroutines

Perbedaannya adalah bahwa launch{} tidak menghasilkan apa-apa, dan async{} mengembalikan contoh yang Deferred yang memiliki fungsi future.get() yang mengembalikan hasil dari coroutine, sama seperti Future in Java, di mana kita melakukan future.get() untuk mendapatkan hasilnya .

Mari kita lihat menggunakan peluncuran {}

 fun main(args: Array<String>) { println("Kotlin Start") launch(CommonPool) { delay(2000) println("Kotlin Inside") } println("Kotlin End") } 

 // The output will be // Kotlin Start // Kotlin End // Kotlin Inside 

Kode ini akan meluncurkan coroutine baru di kumpulan utas ini. Dalam hal ini, kami menggunakan CommonPool , yang menggunakan ForkJoinPool.commonPool () . Streaming masih ada dalam program berbasis coroutine, tetapi satu utas dapat menjalankan banyak coroutine, sehingga tidak perlu terlalu banyak utas.

Mari kita coba satu hal:

 fun main(args: Array<String>) { delay(2000) } 

Jika Anda melakukan ini secara langsung di fungsi utama, Anda akan menerima pesan kesalahan:

Fungsi interupsi hanya dapat dipanggil dari coroutine atau fungsi interupsi lainnya.

Fungsi penundaan adalah fungsi interupsi, jadi kita hanya dapat memanggilnya dari coroutine atau fungsi interupsi lainnya.

Mari kita perbaiki ini:

 fun main(args: Array<String>) { runBlocking { delay(2000) } } 

Contoh lain:

 suspend fun doWorkFor1Seconds(): String { delay(1000) return "doWorkFor1Seconds" } 

 suspend fun doWorkFor2Seconds(): String { delay(2000) return "doWorkFor2Seconds" } 

 // Serial execution private fun doWorksInSeries() { launch(CommonPool) { val one = doWorkFor1Seconds() val two = doWorkFor2Seconds() println("Kotlin One : " + one) println("Kotlin Two : " + two) } } 

 // The output is // Kotlin One : doWorkFor1Seconds // Kotlin Two : doWorkFor2Seconds 

Sekarang mari kita lihat menggunakan async {}

 // Parallel execution private fun doWorksInParallel() { val one = async(CommonPool) { doWorkFor1Seconds() } val two = async(CommonPool) { doWorkFor2Seconds() } launch(CommonPool) { val combined = one.await() + "_" + two.await() println("Kotlin Combined : " + combined) } } // The output is // Kotlin Combined : doWorkFor1Seconds_doWorkFor2Seconds 

Karena async{} kita menggunakan async{} , kita bisa memanggil await() untuk mendapatkan hasilnya.

Selamat belajar;)