Ce elemente de multitasking oferă Kotlin?

Kotlin oferă următoarele elemente de multitreading:

Corutine: Fire ușoare, bazate pe funcții suspendabile. Asigură execuție asincronă și non-blocantă a codului.

Constructori de corutine: Funcții care pornesc corutine. Principalii: launch (pornește o corutină fără a returna o valoare), async (pornește o corutină și returnează un Deferred, care poate fi așteptat pentru a obține rezultatul).

// Exemplu de utilizare launch
GlobalScope.launch {
    println("Salut din corutină ${Thread.currentThread().name}")
}

// Exemplu de utilizare async
val deferred = GlobalScope.async {
    delay(1000) // Simulăm o operație lungă
    "Rezultat"
}
val result = runBlocking { deferred.await() } // Așteptăm rezultatul

Dispatchers: Determină pe ce pool de fire va fi executată corutina. Principalii:
- Dispatchers.Default: Pool comun de fire pentru sarcini intensive CPU.
- Dispatchers.IO: Pool de fire pentru operații de intrare/ieșire blocante (lucru cu fișiere, rețea).
- Dispatchers.Main: Dispatcher pentru firul interfeței utilizatorului pe platformele corespunzătoare (Android, Swing).
- Dispatchers.Unconfined: Corutina pornește în firul curent, dar poate fi reluată în orice fir.
```
GlobalScope.launch(Dispatchers.IO) {
    // Executare intrare/ieșire
}
```
runBlocking: Funcție constructor de corutină care blochează firul curent până la finalizarea corutinei. Folosit pentru a combina cod blocant și non-blocant, adesea în teste sau funcții main.
```
runBlocking {
    launch {
        delay(500)
        println("Finalizat în ${Thread.currentThread().name}")
    }
    println("Pornește în ${Thread.currentThread().name}")
}
```
suspend funcții: Funcții a căror execuție poate fi suspendată și reluată. Pot fi apelate doar din alte funcții suspend sau constructori de corutine.
```
suspend fun doSomething() {
    delay(100) // Exemplu de suspendare
}
```

Job: Handle pentru o corutină pornită. Oferă metode pentru gestionarea ciclului de viață al corutinei (anulare, așteptare finalizare).

val job = GlobalScope.launch {
   // Operație lungă
}
job.cancel() // Anulare corutină
runBlocking { job.join() } // Așteptare finalizare

CoroutineScope: Definește domeniul de vizibilitate pentru corutine. Corutinele lansate în acest domeniu sunt automat anulate la anularea domeniului. Ajută la gestionarea ciclului de viață al corutinei.
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Corutină în acest domeniu
}
scope.cancel() // Anulare toate corutinele din acest domeniu
```

Canale (Channel): Primitivi pentru transmiterea sigură a datelor între corutine. Canalele pot fi unidirecționale (doar pentru trimitere sau recepție) sau bidirecționale.

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Este important să închidem canalul
    }
    launch {
        for (y in channel) println(y)
    }
}

Mutex-uri (Mutex): Primitivi de sincronizare pentru a asigura accesul exclusiv la o resursă comună. Asigură siguranță în fire, permițând doar unei corutine să dețină mutex-ul într-un moment dat.

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

val mutex = Mutex()
var counter = 0

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

Stări (StateFlow, SharedFlow): Primitivi pentru lucrul cu fluxuri de date în contextul programării reactive și multitreading. StateFlow reprezintă un flux "rece" cu starea curentă, iar SharedFlow un flux "fierbinte" pentru difuzarea largă a datelor.