Que mecanismos o Kotlin fornece para trabalhar com…

Coroutines (Coroutines): Fios leves que permitem escrever código assíncrono de forma imperativa, evitando chamadas bloqueantes. Baseiam-se em funções reentrantes e não estão ligados a fios nativos.
Dispatchers: Determinam o fio ou grupo de fios onde a coroutine será executada.
- Dispatchers.Default: Para tarefas que consomem muitos recursos (por exemplo, CPU-bound).
- Dispatchers.IO: Para operações de entrada/saída (por exemplo, pedidos de rede, trabalho com ficheiros).
- Dispatchers.Main: Para executar código no fio principal (por exemplo, atualização de UI numa aplicação Android).
- Dispatchers.Unconfined: Executa a coroutine no fio atual até à primeira chamada a uma função suspensa.
Funções suspend: Funções que podem ser pausadas e retomadas mais tarde. Marcam-se com o modificador suspend.
Contexto: Contém informações sobre a coroutine, como o dispatcher, o job e o gestor de exceções.
Job: Representa o ciclo de vida da coroutine (em execução, ativa, terminada, cancelada). Permite gerir a coroutine (cancelar, esperar que termine).
Scope: Define o âmbito das coroutines, gerindo o seu ciclo de vida.
MutableStateFlow / SharedFlow: Na biblioteca kotlinx.coroutines.flow, permitem trocar dados de forma segura entre coroutines.
Mutex: Primitive de sincronização para proteger secções críticas.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Exemplo de uso de coroutines e dispatcher
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("Coroutine de trabalho: $i")
            delay(100) // Atraso não bloqueante
        }
    }
    println("Coroutine lançada")
    job.join() // Espera que a coroutine termine
    println("Coroutine terminada")
}

// Exemplo de função suspend
suspend fun fetchData(): String {
    delay(1000) // Simulação de pedido de rede
    return "Dados recebidos"
}

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

val mutex = Mutex()
var counter = 0

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

Que mecanismos o Kotlin fornece para trabalhar com cálculos paralelos?