Korutinalarda xatoliklarni boshqarish usullarini bilasizmi?

try...catch bloklaridan foydalanish. Xatoliklarni boshqarishning standart usuli. Korutinalar ichida ishlaydi.

// try-catch qoʻllash
suspend fun fetchData(): String {
    return try {
        // Xatolik chiqarishi mumkin boʻlgan operatsiya
        throw Exception("Ma'lumotlarni yuklashda xato")
        "Ma'lumotlar muvaffaqiyatli yuklandi"
    } catch (e: Exception) {
        "Xato: ${e.message}"
    }
}

try...catch boshqa CoroutineScopeda ishga tushirilgan bolalar korutinalardan chiqarilgan uncaught xatoliklarni boshqarmaydi.

CoroutineExceptionHandler. Bu korutinalar tomonidan chiqarilgan va boshqarilmagan xatoliklarni ushlaydi, agar ular ushbu CoroutineScope yoki uning bolalar CoroutineScopelarida ishga tushirilgan boʻlsa.

// CoroutineExceptionHandler
val handler = CoroutineExceptionHandler { _, exception ->
    println("Ushlangan xato: $exception")
}

// CoroutineExceptionHandlerni qoʻllash
GlobalScope.launch(handler) {
    // Xatolik chiqarishi mumkin boʻlgan korutina
    throw Exception("Korutinadagi xato")
}

CoroutineExceptionHandler faqat strukturali raqobat mexanizmi tomonidan boshqarilmaydigan xatoliklar uchun ishlaydi.

SupervisorJob va supervisorScope. Oddiy Job dan farqli oʻlaroq, xatolik bilan bolalar korutina ota Jobni bekor qilsa, SupervisorJob ota Jobni bekor qilmaydi. supervisorScope SupervisorJob bilan CoroutineScope yaratadi.

// supervisorScope dan foydalanish
suspend fun loadMultipleData() = supervisorScope {
    val data1 = async {
        // Xatolik chiqarishi mumkin
        throw Exception("Ma'lumot 1 da xato")
        "Ma'lumot 1"
    }
    val data2 = async {
        "Ma'lumot 2"
    }

    // Aniq bir `async` uchun xatolikni boshqarish mumkin
    try {
        println("Natija 1: ${data1.await()}")
    } catch (e: Exception) {
        println("Ma'lumot 1 ni yuklashda xato: ${e.message}")
    }
    println("Natija 2: ${data2.await()}")
}

Bu mustaqil bolalar vazifalari uchun ishlatiladi, bunda birining xatosi boshqalarga ta'sir qilmasligi kerak. try...catch yoki CoroutineExceptionHandler ni o'zgartirmaydi, balki xatoliklarning tarqalishini o'zgartiradi.

Strukturali raqobatda xatoliklarni tarqatish. Standart holatda, bolalar korutinasida chiqarilgan xato ota korutina va uning singillarini bekor qiladi.

// Xato tarqalishini misol qilish
runBlocking {
    val job = launch {
        launch { // Bolalar korutina 1
            delay(100)
            throw Exception("Bolalar 1 da xato")
        }
        launch { // Bolalar korutina 2
            delay(200)
            println("Bolalar 2 bajarildi")
        }
    }
    try {
        job.join()
    } catch (e: Exception) {
        println("Ota da xato ushlash: $e")
    }
}

Bu strukturali raqobatning asosiy xulq-atvori boʻlib, resurslar va holatlarning oqib ketishini oldini oladi.

async bilan await() dan foydalanish. async da chiqarilgan xatoliklar avtomatik tarzda tarqatilmaydi. Ular Deferred ichida saqlanadi va faqat await() chaqirilganda chiqariladi.

// async/await bilan xatoliklarni boshqarish
suspend fun safeAsyncCall() = coroutineScope {
    val deferred = async {
        throw Exception("Async da xato")
        "Async natija"
    }

    try {
        val result = deferred.await()
        println("Natija: $result")
    } catch (e: Exception) {
        println("Async dan chiqarilgan xatoni ushlash: ${e.message}")
    }
}

Bu har bir asinxron vazifa uchun xatoliklarni tanlab boshqarishga imkon beradi.