launch और async

runBlocking {
    launch {                       // fire-and-forget
        // work
    }
    val deferred = async {         // returns a result
        value
    }
    val result = deferred.await()
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        println("Doing background work")
    }
    job.join()
    println("Background work complete")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred = async {
        delay(50)
        42
    }
    println("Result: ${deferred.await()}")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val first = async { delay(100); 10 }
    val second = async { delay(100); 20 }
    val total = first.await() + second.await()
    println("Total: $total")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch { println("Just logging, no result needed") }
    val value = async { 100 }.await()
    println("Computed value: $value")
}

Coroutine के Basics · Suspend Functions क्या हैं · Dispatchers क्या हैं · Flow के Basics

1. async से मिले किसी Deferred पर .await() call करना भूल जाना, यानी आप असल में कभी इसका computed result नहीं निकालते।
2. launch से काम चल सकता हो तब async उपयोग करना, जब असल में कोई return value न चाहिए तब अनावश्यक overhead जोड़ते हुए।
3. कई async calls शुरू करना लेकिन उन सभी को शुरू करने के बाद के बजाय हर एक पर तुरंत .await() call करना, उन्हें concurrently चलाने का फायदा खोते हुए।

• launch { } एक coroutine शुरू करता है जो अपने side effects के लिए चलता है और एक Job return करता है, कोई result value नहीं।
• async { } एक coroutine शुरू करता है जो एक result compute करता है, Deferred<T> के रूप में return किया गया, बाद में .await() से निकाला गया।
• किसी को भी await करने से पहले कई async calls शुरू करना उन्हें क्रमवार के बजाय concurrently चलने देता है।
• launch और async दोनों kotlinx.coroutines द्वारा प्रदान किए coroutine builders हैं।