Ce mecanisme oferă Kotlin pentru a lucra cu calcule…

Corutine (Coroutines): Fire ușor de greutate, care permit scrierea codului asincron în stil imperativ, evitând apelurile blocante. Bazate pe funcții reîncepătoare și nu sunt legate de fire native.
Dispatchers: Determină firul sau grupul de fire în care va fi executată corutina.
- Dispatchers.Default: Pentru sarcini intensive în resurse (de exemplu, CPU-bound).
- Dispatchers.IO: Pentru operațiuni de intrare/ieșire (de exemplu, solicitări de rețea, lucru cu fișiere).
- Dispatchers.Main: Pentru executarea codului pe firul principal (de exemplu, actualizarea UI în aplicația Android).
- Dispatchers.Unconfined: Execută corutina pe firul curent până la primul apel al unei funcții suspendate.
Funcții suspend: Funcții care pot fi puse în pauză și reluate mai târziu. Marcate cu modificatorul suspend.
Context: Conține informații despre corutină, cum ar fi dispatcher, job și handler de excepții.
Job: Reprezintă ciclul de viață al corutinei (pornită, activă, finalizată, anulată). Permite gestionarea corutinei (anulare, așteptare finalizare).
Scope: Definește domeniul de aplicare pentru corutine, gestionând ciclul lor de viață.
MutableStateFlow / SharedFlow: În biblioteca kotlinx.coroutines.flow, permit schimbul sigur de date între corutine.
Mutex: Primitive de sincronizare pentru protejarea secțiunilor critice.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Exemplu de utilizare a corutinei și dispatcher
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("Corutină de lucru: $i")
            delay(100) // Întârziere non-blocantă
        }
    }
    println("Corutină lansată")
    job.join() // Așteaptă finalizarea corutinei
    println("Corutină finalizată")
}

// Exemplu de funcție suspend
suspend fun fetchData(): String {
    delay(1000) // Simulare solicitare de rețea
    return "Date primite"
}

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

val mutex = Mutex()
var counter = 0

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

Ce mecanisme oferă Kotlin pentru a lucra cu calcule paralele?