როგორ მუშაობს async და await კონსტრუქციები Android-ის პროგრამირების ენაში?

Kotlin-ში, რომელიც გამოიყენება Android-ის განვითარებისათვის, async და await არის კორუტინების ბიბლიოთეკის ფუნქციები. ისინი არ არის ენის საკვანძო სიტყვები, როგორც ზოგ სხვა ენებში.

async იწყებს ახალ კორუტინას ფონურ რეჟიმში და აბრუნებს Deferred ტიპის ობიექტს, რომელიც წარმოადგენს მომავალში შესრულების შედეგს. async-ს გამოძახებული კორუტინა აგრძელებს თავის მუშაობას, არ ელოდება დაწყებული ასინქრონული ოპერაციის დასრულებას.

await არის შეჩერებადი ფუნქცია, რომელიც გამოიძახება Deferred ობიექტზე. იგი აჩერებს მიმდინარე კორუტინას მანამ, სანამ async-ით დაწყებული ასინქრონული ოპერაცია არ დასრულდება და თავისი შედეგი არ დაბრუნდება. თუ შედეგი უკვე ხელმისაწვდომია, await-ი აბრუნებს მას დაუყოვნებლივ.

სინტაქსი:

import kotlinx.coroutines.*

suspend fun fetchUserData(): String {
    // გრძელი ოპერაციის იმიტაცია
    delay(1000)
    return "User Data"
}

suspend fun processData(data: String): String {
    // სხვა გრძელი ოპერაციის იმიტაცია
    delay(2000)
    return "Processed: $data"
}

suspend fun main() {
    val deferredData = CoroutineScope(Dispatchers.IO).async {
        // ასინქრონულად მონაცემების მიღება
        fetchUserData()
    }

    // შეიძლება სხვა სამუშაოს შესრულება, სანამ მონაცემები იტვირთება

    val data = deferredData.await() // ველოდებით fetchUserData()-ის დასრულებას

    val processedResult = withContext(Dispatchers.Default) {
        // მონაცემების დამუშავება, შესაძლოა სხვა ნაკადზე
        processData(data)
    }

    println(processedResult) // გამოიტანს "Processed: User Data" დაგვიანების შემდეგ
}

ძირითადი მომენტები:

• async აბრუნებს Deferred-ს, რომელიც "მომავალი" შედეგის დაპირებაა.
• await არის შეჩერებადი ფუნქცია და აჩერებს გამოძახებულ კორუტინას.
• გამოიყენება კორუტინების კონტექსტში, ბლოკირებადი არაინფრაქტული ასინქრონული ოპერაციებისათვის.
• საშუალებას აძლევს ერთდროულად რამდენიმე ასინქრონული დავალების შესრულებას და მათი შედეგების შეგროვებას.