Waarom wordt het gebruik van synchronisatieblokken en…

Het gebruik van blokkerende constructies zoals synchronized of lock uit de standaardbibliotheek bij het werken met coroutines leidt tot inefficiënt gebruik van bronnen en kan problemen veroorzaken.

Belangrijkste redenen:

Thread-blokkering: Synchronisatieblokken stoppen de uitvoering van de thread, niet alleen van de coroutines. Als een suspenderende functie wordt uitgevoerd binnen een gesynchroniseerd blok, wordt de thread geblokkeerd totdat de suspenderende functie is voltooid en de lock wordt vrijgegeven. Dit kan leiden tot "honger" van andere coroutines die dezelfde thread gebruiken.
Onverenigbaarheid met suspenderende functies: Het werkmechanisme van coroutines (contextwisseling, voortzettingen) houdt geen rekening met thread-blokkeringen. Het uitvoeren van een suspenderende functie binnen een gesynchroniseerd blok schendt de niet-blokkerende aard van coroutines.
Overschrijding van de principes van gestructureerde gelijktijdigheid: Coroutines hebben hun eigen systeem van annuleringsmarkeringen en hiërarchie. Thread-blokkeringen negeren dit systeem, wat het juiste beheer van annuleringen en levenscyclusbeheer bemoeilijkt.
Risico op deadlocks: De combinatie van thread-blokkeringen en coroutine-concurrentiemechanismen verhoogt de kans op complexe deadlocks die moeilijk te debuggen zijn.

In plaats van thread-blokkeringen voor het synchroniseren van toegang tot gedeelde bronnen in coroutines, moeten gespecialiseerde concurrency-primitieven uit de kotlinx.coroutines-bibliotheek worden gebruikt:

Mutex: Zorgt voor onderlinge uitsluiting. De coroutine die probeert een bezette mutex te verkrijgen, wordt onderbroken (zonder thread te blokkeren) totdat de mutex wordt vrijgegeven.
Semaphore: Beperkt het aantal coroutines dat gelijktijdig toegang heeft tot een bron.
Channel: Wordt gebruikt voor gegevensuitwisseling tussen coroutines.
Atomic variables: Voor eenvoudige atomische bewerkingen.

Voorbeeld van gebruik van 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 {
        // Kritieke sectie
        counter++
    }
}

fun main() = runBlocking {
    // Maak meerdere coroutines voor gelijktijdige toegang
    repeat(1000) {
        launch {
            incrementCounter()
        }
    }
    delay(1000) // Geef tijd voor de coroutines om uit te voeren
    println("Counter: $counter") // Verwacht 1000
}

mutex.withLock is een suspending-functie. Als de mutex bezet is, wordt de coroutine die withLock aanroept onderbroken en wordt de thread vrijgegeven voor andere taken. Wanneer de mutex beschikbaar wordt, wordt de coroutine hervat. Dit blokkeert de thread niet, in tegenstelling tot synchronized.

Waarom wordt het gebruik van synchronisatieblokken en vergelijkbare constructies niet aanbevolen bij het werken met coroutines?