Ի՞նչ սխալների մշակման մեթոդներ եք գիտակցում կորթիններում։

Օգտագործում try...catch բլոկների։ Ստանդարտ եղանակը արտահայտությունների մշակման։ Աշխատում է կուրտինայի ներսում։

// Օգտագործում try-catch
suspend fun fetchData(): String {
    return try {
        // Օպերացիա, որը կարող է արտահայտել արտահայտություն
        throw Exception("Տվյալների բեռնումը սխալ է")
        "Տվյալները հաջողությամբ բեռնված են"
    } catch (e: Exception) {
        "Սխալ: ${e.message}"
    }
}

try...catch չի հարմար է անփոփոխ արտահայտությունների մշակման համար, որոնք արտահայտվում են դուստր կուրտինաներից, որոնք սկսվել են այլ CoroutineScope-ում։

CoroutineExceptionHandler. Հավաքում է անմշակ արտահայտություններ, որոնք արտահայտվում են այն կուրտինաներից, որոնք սկսվել են այս CoroutineScope-ում կամ նրա դուստր CoroutineScope-ներում։

// CoroutineExceptionHandler
val handler = CoroutineExceptionHandler { _, exception ->
    println("Հայտնաբերված արտահայտություն: $exception")
}

// Օգտագործում CoroutineExceptionHandler
GlobalScope.launch(handler) {
    // Կուրտինա, որը կարող է արտահայտել արտահայտություն
    throw Exception("Սխալ կուրտինայում")
}

CoroutineExceptionHandler-ը ակտիվանում է միայն այն արտահայտությունների համար, որոնք չեն մշակվել կառուցվածքային մրցակցությամբ։

SupervisorJob և supervisorScope. Տարբեր է սովորական Job-ից, երբ դուստր կուրտինան սխալի դեպքում հանգեցնում է ծնողական Job-ի չեղարկման։ SupervisorJob-ը չի չեղարկում ծնողական Job-ը սխալի դեպքում։ supervisorScope ստեղծում է CoroutineScope-ը SupervisorJob-ով։

// Օգտագործում supervisorScope
suspend fun loadMultipleData() = supervisorScope {
    val data1 = async {
        // Կարող է արտահայտել արտահայտություն
        throw Exception("Սխալ տվյալներում 1")
        "Տվյալներ 1"
    }
    val data2 = async {
        "Տվյալներ 2"
    }

    // Կարող է մշակել արտահայտություն կոնկրետ async-ի համար
    try {
        println("Արդյունք 1: ${data1.await()}")
    } catch (e: Exception) {
        println("Սխալ տվյալների բեռնում 1-ով: ${e.message}")
    }
    println("Արդյունք 2: ${data2.await()}")
}

Օգտագործվում է անկախ դուստր առաջադրանքների համար, որտեղ սխալը մեկի չի ազդում մյուսների վրա։ Չփոխարինում է try...catch կամ CoroutineExceptionHandler, այլ փոխում է արտահայտությունների տարածման վարքագիծը։

Արտահայտությունների տարածում կառուցվածքային մրցակցությունում։ Դեպքում, արտահայտությունը դուստր կուրտինայում հանգեցնում է ծնողական կուրտինայի և նրա սիբլինգների չեղարկմանը։

// Օրինակ արտահայտության տարածում
runBlocking {
    val job = launch {
        launch { // Դուստր 1
            delay(100)
            throw Exception("Սխալ դուստր 1-ում")
        }
        launch { // Դուստր 2
            delay(200)
            println("Դուստր 2 ավարտվեց")
        }
    }
    try {
        job.join()
    } catch (e: Exception) {
        println("Հայտնաբերված արտահայտություն ծնողում: $e")
    }
}

Սա հիմնական վարքագիծն է կառուցվածքային մրցակցությունում, որը օգնում է խուսափել ռեսուրսների և վիճակների արտահոսքից։

Օգտագործում async և await(). async-ում արտահայտված արտահայտությունները չ տարածվում են ինքնաբերաբար։ Նրանք պահվում են Deferred-ի ներսում և արտահայտվում են միայն await()-ի ժամանակ։

// Արտահայտությունների մշակումը async/await-ով
suspend fun safeAsyncCall() = coroutineScope {
    val deferred = async {
        throw Exception("Սխալ async-ում")
        "Ա async արդյունքը"
    }

    try {
        val result = deferred.await()
        println("Արդյունք: $result")
    } catch (e: Exception) {
        println("Հայտնաբերված արտահայտություն async-ից: ${e.message}")
    }
}

Սա թույլ է տալիս ընտրովի մշակել սխալները յուրաքանչյուր ասինխրոն առաջադրանքի համար։