Kotlin qanday ko'p ipli elementlarni taqdim etadi…

Kotlin quyidagi ko‘p oqim elementlarini taqdim etadi:

Koritinlar: Yengil oqimlar, to‘xtatiladigan funksiyalarga asoslangan. Kodning asinxron va bloklanmaydigan bajarilishini ta'minlaydi.

Koritinlar quruvchilari: Korutinlarni ishga tushiradigan funksiyalar. Asosiylar: launch (qiymat qaytarmaydigan korutinni ishga tushiradi), async (korutinni ishga tushiradi va Deferred ni qaytaradi, natijani kutish mumkin).

// launch dan foydalanish misoli
GlobalScope.launch {
    println("Salom korutindan ${Thread.currentThread().name}")
}

// async dan foydalanish misoli
val deferred = GlobalScope.async {
    delay(1000) // Uzoq davom etadigan operatsiyani taqlid qiladi
    "Natija"
}
val result = runBlocking { deferred.await() } // Natijani kutamiz

Dispatchers: Korutinaning qaysi ishchi to‘plamida bajarilishini belgilaydi. Asosiylar:
- Dispatchers.Default: CPU intensiv vazifalar uchun umumiy ishchi to‘plam.
- Dispatchers.IO: Fayllar, tarmoq bilan ishlash kabi bloklovchi kirish-chiqish operatsiyalari uchun.
- Dispatchers.Main: Mos platformalardagi foydalanuvchi interfeysi uchun dispatcher (Android, Swing).
- Dispatchers.Unconfined: Korutin joriy oqimda boshlanadi, lekin har qanday oqimda davom ettirilishi mumkin.
```
GlobalScope.launch(Dispatchers.IO) {
    // Kirish-chiqishni bajarish
}
```
runBlocking: Korutin quruvchisi funksiyasi, joriy oqimni korutina tugaguncha bloklaydi. Bloklovchi va bloklanmaydigan kodni birlashtirish uchun ishlatiladi, ko‘pincha testlarda yoki main-funksiyalarda.
```
runBlocking {
    launch {
        delay(500)
        println("${Thread.currentThread().name} da tugallandi")
    }
    println("${Thread.currentThread().name} da ishga tushirildi")
}
```
suspend funksiyalar: Boshqa suspend funksiyalar yoki korutin quruvchilardan chaqiriladigan, bajarilishi to‘xtatilishi va davom ettirilishi mumkin bo‘lgan funksiyalar.
```
suspend fun doSomething() {
    delay(100) // To‘xtash misoli
}
```

Job: Ishga tushirilgan korutina uchun handle. Korutinaning hayot aylanishini boshqarish uchun metodlar taqdim etadi (bekor qilish, tugashini kutish).

val job = GlobalScope.launch {
   // Uzoq davom etadigan operatsiya
}
job.cancel() // Korutini bekor qilish
runBlocking { job.join() } // Tugashini kutish

CoroutineScope: Korutinlar uchun doira belgilaydi. Belirli doirada ishga tushirilgan korutinalar, doira bekor qilinganda avtomatik ravishda bekor qilinadi. Hayot aylanishini boshqarishda yordam beradi.
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Bu doirada korutin
}
scope.cancel() // Bu doiradagi barcha korutinalarni bekor qilish
```

Kanal (Channel): Korutinalar o‘rtasida xavfsiz ma’lumot uzatish uchun primitive. Kanallar yagona yo‘nalishli (faqat yuborish yoki qabul qilish) yoki ikki yo‘nalishli bo‘lishi mumkin.

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Kanalni yopish muhim
    }
    launch {
        for (y in channel) println(y)
    }
}

Mutex (Mutex): Sinxronizatsiya primitive, umumiy resursga eksklyuziv kirishni ta’minlaydi. Ish oqimlarining xavfsizligini ta’minlaydi, faqat bitta korutina mutexni bir vaqtning o‘zida egallashi mumkin.

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}

Holatlar (StateFlow, SharedFlow): Ma’lumot oqimlari bilan ishlash uchun primitive’lar. StateFlow — ho‘sh oqim, hozirgi holat bilan, SharedFlow — issiq oqim, keng tarqaladigan ma’lumotlar uchun.

Kotlin qanday ko'p ipli elementlarni taqdim etadi?