Warum wird die Verwendung von Synchronisationsblöcken und ähnlichen Konstruktionen bei der Arbeit mit Koroutinen nicht empfohlen?

Die Verwendung blockierender Konstruktionen wie synchronized oder lock aus der Standardbibliothek bei der Arbeit mit Koroutinen führt zu ineffizienter Ressourcennutzung und kann Probleme verursachen.

Hauptgründe:

• Thread-Blocking: Synchronisationsblöcke stoppen die Ausführung des Threads, nicht nur der Koroutinen. Wenn innerhalb eines synchronisierten Blocks eine Suspending-Funktion ausgeführt wird, wird der Thread blockiert, bis die Suspending-Funktion beendet ist und die Sperre freigegeben wird. Dies kann zu "Hunger" bei anderen Koroutinen führen, die denselben Thread verwenden.
• Inkompatibilität mit Suspending-Funktionen: Der Arbeitsmechanismus der Koroutinen (Kontextwechsel, Fortsetzungen) berücksichtigt keine Thread-Blockierungen. Die Ausführung einer Suspending-Funktion innerhalb eines synchronisierten Blocks verletzt die nicht-blockierende Natur der Koroutinen.
• Verletzung der Prinzipien der strukturierten Konkurrenz: Koroutinen haben ihr eigenes System von Abbruchmarkierungen und Hierarchien. Thread-Blockierungen ignorieren dieses System, was die korrekte Behandlung von Abbrüchen und das Lifecycle-Management erschwert.
• Risiko von Deadlocks: Die Kombination aus Thread-Blockierungen und Mechanismen der Koroutinen-Konkurrenz erhöht die Wahrscheinlichkeit komplexer Deadlocks, die schwer zu debuggen sind.

Anstelle von Thread-Blockierungen zur Synchronisation des Zugriffs auf gemeinsam genutzte Ressourcen in Koroutinen sollten spezialisierte Konkurrenzprimitive aus der kotlinx.coroutines-Bibliothek verwendet werden:

• Mutex: Gewährleistet gegenseitigen Ausschluss. Die Koroutine, die versucht, einen belegten Mutex zu erlangen, wird ausgesetzt (ohne Thread zu blockieren), bis der Mutex freigegeben wird.
• Semaphore: Begrenzung der Anzahl gleichzeitiger Koroutinen, die Zugriff auf eine Ressource haben.
• Channel: Wird zum Austausch von Daten zwischen Koroutinen verwendet.
• Atomare Variablen: Für einfache atomare Operationen.

Beispiel für die Verwendung von Mutex:

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

val mutex = Mutex()
var counter = 0

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

fun main() = runBlocking {
    // Erstellen mehrerer Koroutinen für gleichzeitigen Zugriff
    repeat(1000) {
        launch {
            incrementCounter()
        }
    }
    delay(1000) // Warten, bis die Koroutinen ausgeführt wurden
    println("Counter: $counter") // Erwartet 1000
}

mutex.withLock ist eine suspending-Funktion. Wenn der Mutex besetzt ist, wird die aufrufende Koroutine ausgesetzt und gibt den Thread frei für andere Aufgaben. Wenn der Mutex verfügbar wird, wird die Koroutine wieder aufgenommen. Dies blockiert den Thread nicht, im Gegensatz zu synchronized.