Welche Mechanismen bietet Kotlin für die Arbeit mit…

Coroutines (Coroutines): Leichtgewichtige Threads, die es ermöglichen, asynchronen Code im imperativen Stil zu schreiben und blockierende Aufrufe zu vermeiden. Basieren auf wiederaufnehmbaren Funktionen und sind nicht an native Threads gebunden.
Dispatchers: Bestimmen den Thread oder den Thread-Pool, auf dem die Coroutine ausgeführt wird.
- Dispatchers.Default: Für ressourcenintensive Aufgaben (z.B. CPU-bound).
- Dispatchers.IO: Für Ein- und Ausgabeoperationen (z.B. Netzwerk-Anfragen, Dateiarbeit).
- Dispatchers.Main: Für die Ausführung von Code im Haupt-Thread (z.B. UI-Update in einer Android-App).
- Dispatchers.Unconfined: Führt die Coroutine im aktuellen Thread bis zum ersten Aufruf einer suspend-Funktion aus.
Suspend-Funktionen: Funktionen, die pausiert und später wieder aufgenommen werden können. Mit dem Modifier suspend gekennzeichnet.
Context: Enthält Informationen über die Coroutine, wie den Dispatcher, Job und Fehlerbehandler.
Job: Repräsentiert den Lebenszyklus der Coroutine (gestartet, aktiv, beendet, abgebrochen). Ermöglicht die Steuerung der Coroutine (Abbruch, Warten auf Abschluss).
Scope: Definiert den Geltungsbereich für Coroutines und verwaltet deren Lebenszyklus.
MutableStateFlow / SharedFlow: In der Bibliothek kotlinx.coroutines.flow ermöglichen sie einen sicheren Datenaustausch zwischen Coroutines.
Mutex: Synchronisationsprimitive zum Schutz kritischer Sektionen.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Beispiel für die Verwendung von Coroutines und Dispatchers
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("Arbeits-Coroutine: $i")
            delay(100) // Nicht-blockierende Verzögerung
        }
    }
    println("Coroutine gestartet")
    job.join() // Warten auf Abschluss der Coroutine
    println("Coroutine beendet")
}

// Beispiel für eine suspend-Funktion
suspend fun fetchData(): String {
    delay(1000) // Simulation einer Netzwerkanfrage
    return "Daten empfangen"
}

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

val mutex = Mutex()
var counter = 0

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

Welche Mechanismen bietet Kotlin für die Arbeit mit parallelen Berechnungen?