Kotlin რა მრავალსაფეხურიან ელემენტებს უზრუნველყოფს…

კოტლინი უზრუნველყოფს შემდეგი მრავალმხრივი ელემენტებით:

კორუტინები: მსუბუქი ნაკადები, დაფუძნებული შეჩერებადი ფუნქციებზე. უზრუნველყოფს ასინქრონულ და არაბლოკავ კოდს.

კორუტინების შემქმნელები: ფუნქციები, რომლებიც იწყებენ კორუტინებს. ძირითადი: launch (მოწყენილობის გარეშე იწყებს კორუტინს), async (იწყებს კორუტინს და აბრუნებს Deferred, რომელსაც შეიძლება ელოდოთ შედეგისთვის).

// მაგალითი `launch`-ის გამოყენების
GlobalScope.launch {
    println("გამარჯობა კორუტინიდან ${Thread.currentThread().name}")
}

// მაგალითი `async`-ის გამოყენების
val deferred = GlobalScope.async {
    delay(1000) // გრძელვადიანი ოპერაციის იმიტაცია
    "შედეგი"
}
val result = runBlocking { deferred.await() } // შედეგის ელოდება

Dispatchers: განსაზღვრავს, რომელ ნაკადზე შესრულდება კორუტინა. ძირითადი:
- Dispatchers.Default: საერთო ნაკადი CPU-ინტენსიურ დავალებებისთვის.
- Dispatchers.IO: ნაკადი ბლოკირებადი ოპერაციებისათვის (ფაილები, ქსელი).
- Dispatchers.Main: დისპეტჩერი მომხმარებლის ინტერფეისის ნაკადისთვის შესაბამის პლატფორმებზე (Android, Swing).
- Dispatchers.Unconfined: კორუტინა იწყება მიმდინარე ნაკადში, მაგრამ შეიძლება განახლდეს ნებისმიერ ნაკადზე.
```
GlobalScope.launch(Dispatchers.IO) {
    // I/O ოპერაციების შესრულება
}
```
runBlocking: კორუტინის მშენებლობის ფუნქცია, რომელიც ბლოკავს მიმდინარე ნაკადს კორუტინის დასრულებამდე. გამოიყენება ბლოკირებადი და არ ბლოკირებადი კოდის გაერთიანებისთვის, ხშირად ტესტებში ან main-ფუნქციებში:
```
runBlocking {
    launch {
        delay(500)
        println("დასრულდა ${Thread.currentThread().name}")
    }
    println("დაწყებულია ${Thread.currentThread().name}")
}
```
suspend ფუნქციები: ფუნქციები, რომლის შესრულებაც შეიძლება შეჩერდეს და განახლდეს. შეიძლება იძახოს მხოლოდ სხვა suspend ფუნქციებიდან ან კორუტინების მშენებლებიდან:
```
suspend fun doSomething() {
    delay(100) // შეჩერების მაგალითი
}
```
Job: ხელთათმანზე დაწყებული კორუტინა. უზრუნველყოფს მეთოდებს კორუტინის სიცოცხლის ციკლის მართვისთვის (გაუქმება, დასრულების მოლოდინი):
```
val job = GlobalScope.launch {
   // გრძელვადიანი ოპერაცია
}
job.cancel() // კორუტინის გაუქმება
runBlocking { job.join() } // დასრულების მოლოდინი
```
CoroutineScope: განსაზღვრავს კორუტინების ზონას. კორუტინები, რომლებიც იწყება განსაზღვრულ ზონაში, ავტომატურად გაუქმდება ზონის გაუქმებისას. ეხმარება კორუტინების სიცოცხლის ციკლის მართვაში:
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // კორუტინა ამ ზონაში
}
scope.cancel() // ყველა კორუტინის გაუქმება ამ ზონაში
```
კანალები (Channel): პრიმიტივები უსაფრთხო მონაცემთა გადაცემისთვის კორუტინებს შორის. კანალები შეიძლება იყოს ერთმხრივი (მხოლოდ გამოგზავნა ან მიღება) ან ორმხრივი:
```
import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // მნიშვნელოვანია კანალის დახურვა
    }
    launch {
        for (y in channel) println(y)
    }
}
```
მიუტექსები (Mutex): სინქრონიზაციის პრიმიტივები საერთო რესურსზე ექსკლუზიური წვდომის უზრუნველსაყოფად. უზრუნველყოფს ნაკადების უსაფრთხოებას, მხოლოდ ერთ კორუტინს შეუძლია მიუტექსის მფლობელობა ერთდროულად:
```
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}
```
სახელმწიფოები (StateFlow, SharedFlow): მონაცემთა ნაკადები რეაქტიული პროგრამირების და მრავალნაკადიანი კონტექსტისთვის. StateFlow წარმოადგენს "ცივი" ნაკადს მიმდინარე მდგომარეობით, ხოლო SharedFlow — "ცხელ" ნაკადს მონაცემების გავრცელებისთვის.

Kotlin რა მრავალსაფეხურიან ელემენტებს უზრუნველყოფს?