What mechanisms does Kotlin provide for working with parallel computations?

• Coroutines: Lightweight threads that allow writing asynchronous code in an imperative style, avoiding blocking calls. Based on suspendable functions and not tied to native threads.
• Dispatchers: Define the thread or thread pool where the coroutine will run.
  • Dispatchers.Default: For resource-intensive tasks (e.g., CPU-bound).
  • Dispatchers.IO: For I/O operations (e.g., network requests, file handling).
  • Dispatchers.Main: For executing code on the main thread (e.g., updating UI in an Android app).
  • Dispatchers.Unconfined: Executes the coroutine in the current thread until the first suspend function call.
• Suspend functions: Functions that can be paused and resumed later. Marked with the suspend modifier.
• Context: Contains information about the coroutine, such as dispatcher, job, and exception handler.
• Job: Represents the lifecycle of a coroutine (started, active, completed, canceled). Allows managing the coroutine (cancel, wait for completion).
• Scope: Defines the scope for coroutines, managing their lifecycle.
• MutableStateFlow / SharedFlow: In the kotlinx.coroutines.flow library, allow safe data exchange between coroutines.
• Mutex: A synchronization primitive for protecting critical sections.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Example of using coroutines and dispatcher
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("Worker coroutine: $i")
            delay(100) // Non-blocking delay
        }
    }
    println("Started coroutine")
    job.join() // Wait for the coroutine to finish
    println("Coroutine completed")
}

// Example suspend function
suspend fun fetchData(): String {
    delay(1000) // Simulate network request
    return "Data received"
}

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

val mutex = Mutex()
var counter = 0

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