🚴‍♂️Giriş | Coroutine

Coroutine yapısı, ne işe yarar, nedir, neden kullanılır ve temel kullanım örnekleri nelerdir

🔮 Ne İşe Yarar

• 🕊️ Thread işlemlerini kolaylaştıran bir hafif yapıdır

• 👷‍♂️ Coroutine ile inline thread kullanabilirsin

• ✨ Otomatik olarak optimize edilirler

📢 Kullanabilmek için Kotlin Coroutine desteğini buradan projene eklemen lazım

🧱 Temel Kullanım

• 🧐 GlobalScope bağımsız olarak çalışır

• 🙄 İçinde bulunduğu thread bitse bile devam eder

• 🌇 GlobalScope.launch {} coroutine'i işi bitince sonlanır (daemon)

• 👪 repeat ile birden fazla tekrarlanabilir

import kotlinx.coroutines.*

fun main() { 
    GlobalScope.launch { // Arka planda yeni bir işlem (coroutine) başlatır
        delay(1000L)
        println("World!")
    }
    println("Hello,") // Ana thread üzerinde çalışır
    runBlocking {     // Bu alandaki işlemler de ana thread'i engeller
        delay(2000L)  // ... 2s gecikmeden sonra JVM çalışmaya devam eder
    } 
}

// Unit döndüren bir coroutine tanımlama (yukarıdaki ile aynıdır)
fun main() = runBlocking<Unit> { 
    GlobalScope.launch { 
        delay(1000L)
        println("World!")
    }
    println("Hello,")
    delay(2000L)
}

// Tekrarlı kullanım ypaısı
fun main() = runBlocking<Unit> { 
    GlobalScope.launch { 
        delay(1000L)
        println("World!")
    }
    repead(3) {
        println("Hello,")
        delay(2000L)
    }
}

🏗️ İş Oluşturma

• 🏃‍♂️ Thread nesnelerinden farklı olarak Job hemen başlatılır

• ✋ Durdurmak için cancel metodu kullanılır

val job = GlobalScope.launch { // Coroutine oluşturma (thread oluşturma gibi)
    delay(1000L)
    println("World!")
}
println("Hello,")
job.join() // Coroutine bitene kadar bekleme (thread.join() gibi)

val startTime = System.currentTimeMillis()
val job = launch(Dispatchers.Default) {
    var nextPrintTime = startTime
    var i = 0
    while (isActive) { // cancellable computation loop
        // print a message twice a second
        if (System.currentTimeMillis() >= nextPrintTime) {
            println("job: I'm sleeping ${i++} ...")
            nextPrintTime += 500L
        }
    }
}
delay(1300L) // delay a bit
println("main: I'm tired of waiting!")
job.cancelAndJoin() // cancels the job and waits for its completion
println("main: Now I can quit.")

💠 Suspend Metotlar

• 🚫 Coroutine içeren metotlar suspent anahtarı ile belirtilir

• 💫 async içerisinde kullanılarak asenkron çalışabilirler

• 🛑 await metodu ile çalışmasını tamamlaması beklenebilir

• 🙄 GlobalScope.async {} yapısı ile diğer diller gibi çalışabilir ama tavsiye edilmez

fun main() = runBlocking<Unit> {
    val time1 = measureTimeMillis { // 2017ms
        val one1 = doSomethingUsefulOne()
        val two1 = doSomethingUsefulTwo()
        println("The answer is ${one + two}")
    }
    println("Completed in $time ms")

    val time2 = measureTimeMillis { // 1017ms <- Async çalıştığı için daha hızlı
        val one2 = async { doSomethingUsefulOne() }
        val two2 = async { doSomethingUsefulTwo() }
        println("The answer is ${one.await() + two.await()}")
    }
    println("Completed in $time ms")
    
    val time3 = measureTimeMillis{ // 1017ms <- Async çalışır
        one2.await() + two2.await() 
    }
}

suspend fun concurrentSum(): Int = coroutineScope {
    val one = async { doSomethingUsefulOne() }
    val two = async { doSomethingUsefulTwo() }
    one.await() + two.await()
}

suspend fun doSomethingUsefulOne(): Int {
    delay(1000L) // pretend we are doing something useful here
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    delay(1000L) // pretend we are doing something useful here, too
    return 29
}

‍🧙‍♂ Detaylı bilgi için Composing Suspending Functions alanına bakabilirsin.