Kotlin asinxron operatsiyalar bilan ishlash uchun…

Kotlin asinxron operatsiyalarni soddalashtirish uchun korutinlarni (coroutines) taqdim etadi, ular yengil oqimlar bo'lib, asosiy oqimni bloklamaydi.

Asosiy imkoniyatlar:

Suspension Functions: suspend kalit so'zi bilan belgilangan funksiyalar, ular to'xtatilishi va davom ettirilishi mumkin. Ular bajarilayotgan oqimni bloklamaydi.
```
suspend fun fetchData(): String {
    delay(1000) // Uzun operatsiyani taqlid qilish
    return "Ma'lumotlar olindi"
}
```
Korutinlar quruvchilari: Korutinlarni ishga tushirish uchun funksiyalar:
- launch: Yangi korutinni ishga tushiradi va Job ni qaytaradi (bloklamaydi).
```
GlobalScope.launch {
    println("Korutin ishga tushirildi")
}
```
- async: Yangi korutinni ishga tushiradi va Deferred<T> ni qaytaradi (.await() chaqirilganda bloklanadi).
```
val deferred = GlobalScope.async {
    fetchData()
}
// ...
val result = deferred.await() // Natijani kutish
```
- runBlocking: Korutin tugaguncha joriy oqimni bloklaydi (bloklamaydigan kodlar orasida ko'prik uchun, masalan, testlarda).
```
runBlocking {
    val data = fetchData()
    println(data)
}
```
Korutin konteksti: Korutinning xulq-atvorini belgilovchi elementlar to'plami, Dispatcher va Job ni o'z ichiga oladi.
- Dispatcher: Korutin ishlayotgan oqim yoki oqimlar to'plamini belgilaydi.
Dispatchers: Threadlarni boshqarish uchun ichki obyektlar:
- Dispatchers.Default: Umumiy fon oqimlar havzasi.
- Dispatchers.IO: Kiritish/Chiqish uchun optimallashtirilgan (disk, tarmoq operatsiyalari).
- Dispatchers.Main: Asosiy UI oqimi (Android, JavaFX va boshqalar uchun).
- Dispatchers.Unconfined: Korutinni joriy oqimda ishga tushiradi, ammo to'xtatilgandan so'ng har qanday oqimda davom etishi mumkin.
```
GlobalScope.launch(Dispatchers.IO) {
    // Kiritish/Chiqish oqimida bajariladi
}
```

Strukturalar bilan asinxronlik: Korutinlar ota (CoroutineScope) ga ega bo'lib, ota bekor qilinganda avtomatik ravishda bekor qilinadi. Bu resurslar oqishini oldini oladi va hayot aylanishini boshqarishni soddalashtiradi.

// CoroutineScope avtomatik ravishda bolalar korutinlarini boshqaradi
val scope = CoroutineScope(Dispatchers.Default)
val job = scope.launch {
    // ...
}
// Scope bekor qilinganda, barcha bolalar korutinlari bekor qilinadi
scope.cancel()

Kanallar: Korutinlar o'rtasida xavfsiz ma'lumot uzatish uchun. Ular:
- Bepufrli: Qabul qilish faqat yuborilgandan so'ng amalga oshiriladi.
- Buxgalteriy: Bir nechta elementlarni yuborishga imkon beradi, bloklashdan oldin.
- Conflated: Faqat oxirgi yuborilgan elementni saqlaydi.
```
val channel = Channel<Int>()

scope.launch {
    for (x in 1..5) channel.send(x)
    channel.close()
}

scope.launch {
    for (y in channel) println(y)
}
```

Flow: Ma'lumotlar oqimi, u bir nechta qiymatlarni asinxron ravishda chiqarishi mumkin. RxJava Observable ga o'xshash, ammo korutinlar bilan yanada yengil va integratsiyalashgan.

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i) // Qiymatni yuborish
    }
}

runBlocking {
    simpleFlow().collect { value -> println(value) } // Foydalanish
}

Ushbu imkoniyatlar asinxron kodni imperativ uslubda yozishga imkon beradi, uni o'qilishi oson va saqlash uchun qulay qiladi, callbacklar yoki Future o'rniga.

Kotlin asinxron operatsiyalar bilan ishlash uchun qanday imkoniyatlarni taqdim etadi?