suspend function: bu nima, sintaksis va korutinlarda ishlashi

Kotlin da suspend function nima?

Suspend function — bu suspend kalit so'zi bilan e'lon qilingan, oqimni bloklamasdan bir yoki bir nechta nuqtada bajarilishini to'xtata oladigan funksiyadir. Boshqa suspend funksiyasi ichidagi har bir suspend funksiyasi chaqiruvi potentsial to'xtash nuqtasidir.

suspend fun fetchUserData(): User {
    val response = httpClient.get("/user")
    return parser.parse(response)
}

Kotlin kompilyatori bunday funksiyani state-mashinasiga o'zgartiradi. Har bir to'xtash nuqtasi (boshqa suspend funksiyasining chaqiruvi) state (label) ga aylanadi. Joriy oqim state-lar orasida bo'shatiladi va kutilayotgan operatsiya tugagandan so'ng, bajarilish keyingi state dan davom etadi.

Paydo bo'lish tarixi

Suspend funksiyalari Kotlin 1.3 da (2018 yil) korutinlar bilan birga eksperimental xususiyat sifatida paydo bo'ldi va Kotlin 1.5 da (2021 yil) barqarorlashdi. Bungacha Kotlin/Java da asinxronlik callback-lar, RxJava va CompletableFuture orqali ta'minlanardi. Suspend funksiyalari chiziqli sintaksis va avtomatik oqim boshqaruvi bilan muqobil taklif qildi.

Suspend funksiyalari qanday ishlaydi: Continuation va state-mashinasi

Suspend funksiyalarining ichki tuzilishini tushunish korutinlar bilan to'g'ri ishlashning kalitidir. Oddiy funksiyalardan farqli o'laroq, har bir suspend funksiyasi Continuation interfeysiga ega sinfga kompilyatsiya qilinadi.

Continuation — yashirin parametr

Kotlin kompilyatori suspend funksiyasining har bir parametri oxiriga Continuation turidagi parametr qo'shadi. Continuation quyidagilarni o'z ichiga oladi:

• context — CoroutineContext (dispetcher, job, kontekst elementlari)
• resumeWith — natija yoki istisno bilan bajarilishni tiklash metodi
• label — state-mashinasidagi joriy state indeksi

Misol bilan state-mashinasi

Faraz qilaylik, boshqa suspend funksiyalariga ikkita chaqiruvga ega suspend funksiyamiz bor:

suspend fun process() {
    val a = stepOne()
    val b = stepTwo(a)
    println(b)
}

Kompilyator uni belgilar bilan state-mashinasiga o'zgartiradi:

// Yaratilgan kodning soddalashtirilgan ko'rinishi
fun process(cont: Continuation<Unit>): Any? {
    val cont = cont as ProcessContinuation
    when (cont.label) {
        0 -> {
            cont.label = 1
            if (stepOne(cont) == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
        }
        1 -> {
            cont.label = 2
            val a = cont.result as TypeA
            if (stepTwo(a, cont) == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
        }
        2 -> {
            println(cont.result)
            Unit
        }
    }
}

Asosiy kuzatish: agar funksiya COROUTINE_SUSPENDED qaytarsa, joriy oqim bo'shatiladi. Asinxron operatsiya tugagach, Continuation.resumeWith chaqiriladi va state-mashinasi keyingi label dan davom etadi.

Suspend funksiyalarining sintaksisi: e'lon va chaqirish

Suspend funksiyasining e'loni oddiy funksiyadan farq qilmaydi, faqat fun dan oldin suspend kalit so'zi qo'shiladi. Faqat bitta cheklov bor: suspend funksiyasini faqat korutindan yoki boshqa suspend funksiyasidan chaqirish mumkin.

Asosiy e'lon

suspend fun delayAndReturn(ms: Long): String {
    delay(ms)
    return "Done after ${ms}ms"
}

Ushbu misolda delay ham suspend funksiyasidir, u korutinani oqimni bloklamadan belgilangan millisekundga to'xtatadi. Kechikishdan so'ng bajarilish tiklanadi.

Korutindan chaqirish

fun main() = runBlocking {
    val result = delayAndReturn(1000)
    println(result)
}

runBlocking oddiy dunyo bilan korutinlar o'rtasida ko'prik yaratadi. Lambda ichida istalgan suspend funksiyasini chaqirish mumkin.

Suspend lambdalari va funksional turlar

Kotlin funksional turlarning suspend versiyalarini qo'llab-quvvatlaydi — suspend () -> T va suspend (A) -> B. Bu asinxron lambdalarni yuqori darajali funksiyalarga uzatish imkonini beradi:

suspend fun  withRetry(
    retries: Int = 3,
    block: suspend () -> T
): T {
    repeat(retries - 1) {
        try { return block() }
        catch (_: Exception) { delay(100) }
    }
    return block()
}

withRetry funksiyasi suspend lambda qabul qiladi va xatolarda uni qayta bajaradi. Bu qayta urinishlar bilan tarmoq so'rovlari uchun odatiy naqshdir.

Suspend funksiyalari oddiylardan qanday farq qiladi

Suspend va oddiy funksiyalar o'rtasidagi farqlar oddiy modifikator qo'shishdan tashqariga chiqadi. Keling, asosiy farqlarni ko'rib chiqaylik.

Nega suspend funksiyalarini oddiylardan chaqirib bo'lmaydi

Oddiy funksiyada Continuation yo'q — holatni saqlash va bajarilishni tiklash uchun joyi yo'q. Agar oddiy funksiyadan suspend funksiyasini chaqirish kerak bo'lsa, runBlocking (testlar uchun) yoki CoroutineScope.launch (ishlab chiqarish uchun lifecycle ni hisobga olgan holda) dan foydalaning.

Android da suspend funksiyalari misollari

Kotlin da Android ilovalarida suspend funksiyalaridan foydalanishning uchta real stsenariysini ko'rib chiqaylik.

Misol 1: Room DAO suspend so'rovlari bilan

Room suspend funksiyalarini bevosita qo'llab-quvvatlaydi — so'rov avtomatik ravishda fon oqimida bajariladi:

@Dao
interface UserDao {
    @Query("SELECT * FROM users WHERE id = :id")
    suspend fun getUser(id: Int): User?

    @Insert
    suspend fun insertUser(user: User)
}

Room ichki ravishda so'rovni bajarish uchun Dispatchers.IO dan foydalanadi va natija suspend funksiyasi chaqirilgan dispetcherga qaytariladi.

Misol 2: Ekran yuklash uchun suspend funksiyalari kompozitsiyasi

class ProfileViewModel : ViewModel() {
    private val repo = ProfileRepository()

    fun loadProfile(id: String) {
        viewModelScope.launch {
            val profile = repo.getProfile(id)
            _profile.value = profile
        }
    }
}

ViewModelScope.launch korutin yaratadi, uning ichida getProfile suspend funksiyasi chaqiriladi. Natija olingandan so'ng UI asosiy oqimda yangilanadi.

Misol 3: Ketma-ket asinxron qadamlar

suspend fun placeOrder(cart: Cart): OrderResult {
    val validated = validateCart(cart)
    val payment = processPayment(validated)
    val receipt = sendReceipt(payment)
    return receipt
}

Uchta suspend funksiyasi ketma-ket bajariladi. Har bir qadamda korutina oqimni bloklamasdan to'xtashi mumkin. Agar biror qadam istisno tashlasa — qolganlari bajarilmaydi, bu buyurtmaning noto'g'ri holatlaridan himoya qiladi.

Suspend funksiyalari bilan ishlashda odatiy xatolar

Hatto tajribali Kotlin dasturchilari ham suspend funksiyalarini loyihalashda xato qiladilar. Eng keng tarqalganlarini ko'rib chiqaylik.

Xato 1: Suspend ichida bloklovchi chaqiruvlar

Suspend funksiyasi kodni avtomatik ravishda asinxron qilmaydi. Thread.sleep(), InputStream.read() va boshqa bloklovchi chaqiruvlar baribir oqimni bloklaydi. Bloklovchi operatsiyalarni o'rash uchun withContext(Dispatchers.IO) dan foydalaning.

Xato 2: Keraksiz suspend funksiyalari yaratish

Agar funksiya boshqa suspend funksiyalarini chaqirmasa va asinxron operatsiyalarni bajarmasa — suspend modifikatori ortiqcha. State-mashinasiga qo'shimcha yuk qo'shadi va chaqiruv kontekstini cheklaydi. Funksiyani faqat haqiqatan to'xtaganda suspend qiling.

Xato 3: CancellationException ni e'tiborsiz qoldirish

Korutin bekor qilinganda, suspend funksiyalari CancellationException tashlaydi. Uni o'ylamasdan tutmang — chaqiruvchi kodni bekor qilishni to'g'ri yakunlash imkoniyatidan mahrum qilasiz. Agar yakunlovchi operatsiyani bajarish kerak bo'lsa, finally bloki va NonCancellable dan foydalaning.

suspend fun safeOperation() {
    try {
        doWork()
    } finally {
        withContext(NonCancellable) {
            cleanup()
        }
    }
}

finally bloki har doim bajariladi, bekor qilishni ham o'z ichiga oladi, NonCancellable esa tozalashning uzilmasligini kafolatlaydi.

Xato 4: Suspend funksiyalarini callback lardan chaqirish

Korutin yaratmasdan callback dan to'g'ridan-to'g'ri suspend funksiyasini chaqirib bo'lmaydi. Callback uslubini korutinlarga moslashtirish uchun suspendCoroutine yoki suspendCancellableCoroutine dan foydalaning.