Kotlin Coroutines-ში რა ძირითადი კლასი არსებობს?

კოტლინ კორუტინების ძირითადი კლასი და კონცეფციები:

• CoroutineScope: განსაზღვრავს კორუტინების ციკლს, რომლებიც მასში იწყება. საშუალებას აძლევს გაუქმდეს ყველა შვილკორუტინა.

• Job: წარმოადგენს კორუტინის ჰენდლს. საშუალებას აძლევს თვალთვალს მისი მდგომარეობის, დასრულების მოლოდინს, გაუქმებას.

• Deferred: Job-ის სპეციალური ტიპი, რომელიც წარმოადგენს მნიშვნელობას, რომელიც მოგვიანებით იქნება ხელმისაწვდომი. გამოიყენება ასინქრონული გამოთვლებისთვის, რომლებიც აბრუნებენ შედეგს. შედეგი მიიღება .await()-ის საშუალებით.

• Dispatcher: განსაზღვრავს ნაკადს ან ნაკადების პულს, სადაც შესრულდება კორუტინა. ძირითადი დისპეტჩერები:

  • Dispatchers.Default: ოპტიმიზირებულია CPU-ინტენსიურ დავალებებზე. იყენებს საერთო ნაკადების პულს.
  • Dispatchers.IO: ოპტიმიზირებულია I/O ოპერაციების (სხვა ქსელი, დისკი)თვის. იყენებს შესაბამის რაოდენობის ნაკადებს.
  • Dispatchers.Main: მთავარი UI ნაკადი. განახლებისთვის. ხელმისაწვდომია Android და სხვა პლატფორმებზე შესაბამისი დამოკიდებულებით.
  • Dispatchers.Unconfined: იწყებს კორუტინას მიმდინარე ნაკადში, მაგრამ განაახლებს მას ნებისმიერ ნაკადში, რომელიც განაახლებს suspending-ფუნქციას.

• Suspending function: ფუნქცია, რომელიც მონიშნულია suspend-ით და შეიძლება იყოს შეჩერებული და შემდეგ განახლებული. შეუძლია სხვა suspending-ფუნქციების გამოძახება.

• runBlocking: ბლოკავს მიმდინარე ნაკადს ყველა კორუტინის დასრულებამდე. გამოიყენება ძირითადად ტესტირებისთვის და main-ში.

• launch: იწყებს ახალ კორუტინას, რომელიც არ ბლოკავს მიმდინარე ნაკადს და აბრუნებს Job-ს.

• async: იწყებს ახალ კორუტინას, რომელიც არ ბლოკავს მიმდინარე ნაკადს და აბრუნებს Deferred-ს.

გამოყენების მაგალითები:

// CoroutineScope, launch და Dispatchers.IO გამოყენების მაგალითი
import kotlinx.coroutines.*

fun main() = runBlocking {
    // შექმნა CoroutineScope
    val scope = CoroutineScope(Dispatchers.IO)

    // დაწყება კორუტინას IO დისპეტჩერში
    val job: Job = scope.launch {
        // შესრულება ქსელური მოთხოვნის ან სხვა I/O ოპერაციის
        delay(1000) // იმიტაცია სამუშაოს
        println("კორუტინა დასრულდა ${Thread.currentThread().name}-ში")
    }

    // დაველოდოთ კორუტინას დასრულებას
    job.join()
    println("მთავარი ფუნქცია დასრულდა")
}

// async და Deferred გამოყენების მაგალითი
import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredSum: Deferred<Int> = async {
        delay(500)
        1 + 1
    }

    // დაველოდოთ შედეგს
    val result = deferredSum.await()
    println("შედეგი არის: $result")
}