რა მექანიზმებს სთავაზობს Kotlin პარალელური გამოთვლებისთვის?

• კორუტინები (Coroutines): მსუბუქი ნაკადები, რომლებიც საშუალებას აძლევენ ასინქრონული კოდის დაწერას იმპერატიული სტილში, თავიდან აიცილონ ბლოკირებადი ზარები. დაფუძნებულია აღდგენის ფუნქციებზე და არ არის დაკავშირებული ნატურალურ ნაკადებთან.
• Dispatchers: განსაზღვრავს ნაკადს ან ნაკადების პულს, სადაც შესრულდება კორუტინა:
  • Dispatchers.Default: რესურსის ინტენსიური დავალებებისთვის (მაგ., CPU-კერძო)
  • Dispatchers.IO: I/O ოპერაციებისათვის (მაგ., ქსელის მოთხოვნები, ფაილების მუშაობა)
  • Dispatchers.Main: მთავარი ნაკადში კოდის შესრულებისთვის (მაგ., UI განახლება Android-ის აპლიკაციაში)
  • Dispatchers.Unconfined: კორუტინა შესრულდება მიმდინარე ნაკადში, სანამ პირველი suspend-ფუნქცია არ გამოიძახება
• Suspend-ფუნქციები: ფუნქციები, რომლებიც შეიძლება შეჩერდეს და მოგვიანებით განახლდეს. მონიშნულია suspend მორფოთით.
• Context: შეიცავს ინფორმაციას კორუტინზე, როგორიცაა dispatcher, job და გამონაკლისების დამუშავებელი.
• Job: წარმოადგენს კორუტინის სიცოცხლის ციკლს (დაწყებული, აქტიური, დასრულებული, გაუქმებული). საშუალებას აძლევს მართოთ კორუტინა (გაუქმება, მოლოდინი დასრულების)
• Scope: განსაზღვრავს კორუტინების ხილვადობის სფეროს, მართავს მათი სიცოცხლის ციკლს.
• MutableStateFlow / SharedFlow: kotlinx.coroutines.flow ბიბლიოთეკაში, უზრუნველყოფს უსაფრთხო მონაცემთა გაცვლას კორუტინებს შორის.
• Mutex: სინქრონიზაციის primitive, რომელიც იცავს კრიტიკულ სექციებს.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // კორუტინებისა და dispatcher-ის გამოყენების მაგალითი
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("სამუშაო კორუტინა: $i")
            delay(100) // ბლოკირებადი არ არის ხანგრძლივი გაჩერება
        }
    }
    println("კორუტინა დაიწყო")
    job.join() // ველით კორუტინის დასრულებას
    println("კორუტინა დასრულდა")
}

// Suspend-ფუნქციის მაგალითი
suspend fun fetchData(): String {
    delay(1000) // ქსელური მოთხოვნის იმიტაცია
    return "მონაცემები მიღებულია"
}

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}