Milliseid mitme lõime elementi pakub Kotlin?

Kotlin pakub järgmisi mitme niidi elemente:

Korutinaid: Kerged voogud, mis põhinevad peatamise funktsioonidel. Tagavad asünkroonse ja mitteblokeeriva koodi täitmise.

Korutinate ehitajad: Funktsioonid, mis käivitavad korutinaid. Peamised: launch (käivitab korutina ilma väärtust tagastamata), async (käivitab korutina ja tagastab Deferred, mida saab oodata tulemuse saamiseks).

// Näide `launch` kasutamisest
GlobalScope.launch {
    println("Tervist korutina ${Thread.currentThread().name}")
}

// Näide `async` kasutamisest
val deferred = GlobalScope.async {
    delay(1000) // Pika operatsiooni imiteerimine
    "Tulemus"
}
val result = runBlocking { deferred.await() } // Ootame tulemust

Dispatchers: Määrab, millisel niidupulgal korutina täidetakse. Peamised:
- Dispatchers.Default: Üldine niidupulk CPU-intensiivsete ülesannete jaoks.
- Dispatchers.IO: Niidupulk blokeerivate sisendi/väljundi operatsioonide jaoks (failid, võrk).
- Dispatchers.Main: Dispetšer kasutajaliidese voogude jaoks vastavates platvormides (Android, Swing).
- Dispatchers.Unconfined: Korutina käivitatakse praeguses voos, kuid võib jätkata mis tahes niidil.
```
GlobalScope.launch(Dispatchers.IO) {
    // Sisendi/väljundi täitmine
}
```
runBlocking: Korutina ehitaja funktsioon, mis blokeerib praeguse voolu kuni korutina lõppemiseni. Kasutatakse blokeeriva ja mitteblokeeriva koodi ühendamiseks, sageli testides või main-funktsioonides:
```
runBlocking {
    launch {
        delay(500)
        println("Lõpetatud ${Thread.currentThread().name}")
    }
    println("Käivitatud ${Thread.currentThread().name}")
}
```
suspend funktsioonid: Funktsioonid, mille täitmine võib peatuda ja jätkata. Neid saab kutsuda ainult teistest suspend funktsioonidest või korutina ehitajatest:
```
suspend fun doSomething() {
    delay(100) // Peatamise näide
}
```

Job: Käivitatud korutina käepide. Pakub meetodeid korutina elutsükli haldamiseks (tühistamine, lõpetamise ootamine):

val job = GlobalScope.launch {
   // Pikk operatsioon
}
job.cancel() // Korutina tühistamine
runBlocking { job.join() } // Lõpetamise ootamine

CoroutineScope: Määratleb korutinate vahemiku. Korutinaid, mis käivitatakse kindlas vahemikus, automaatselt tühistatakse vahemiku tühistamisel. Aitab hallata korutinate elutsüklit:
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Korutina selles vahemikus
}
scope.cancel() // Kõigi korutinate tühistamine selles vahemikus
```

kanalid (Channel): Primitivsed turvaliseks andmeedastuseks korutinate vahel. Kanalid võivad olla ühepoolsed (saadetakse või vastu võetakse) või kahepoolsed:

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Oluline on kanali sulgemine
    }
    launch {
        for (y in channel) println(y)
    }
}

Mutexid (Mutex): Sünkroniseerimise primitiivid, mis tagavad eksklusiivse juurdepääsu ühisele ressursile. Tagab voogude turvalisuse, lubades ainult ühel korutinal omada mutexi korraga:

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

val mutex = Mutex()
var counter = 0

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

Olekuvood (StateFlow, SharedFlow): Andmevoodid reaktiivseks programmeerimiseks ja mitmevoogulises kontekstis. StateFlow esindab "külma" voogu praeguse olekuga, SharedFlow aga "kuuma" voogu andmete levitamiseks.