Hoe werkt een mutex in coroutines?

Een mutex (Mutual Exclusion) in coroutines biedt een mechanisme van wederzijdse uitsluiting om gedeelde bronnen te beschermen tegen gelijktijdige toegang door meerdere coroutines.

Werking principe:

1. Verkrijgen van de mutex: De coroutine die toegang wil tot de beschermde bron roept de methode lock() aan.
2. Blokkering: Als de mutex vrij is, wordt deze zonder blokkering verkregen en gaat de uitvoering door. Als de mutex door een andere coroutine bezet is, wordt de aanroepende coroutine gepauzeerd totdat de mutex wordt vrijgegeven.
3. Vrijgave van de mutex: Na voltooiing van de werkzaamheden met de beschermde bron, roept de coroutine de methode unlock() aan om de mutex vrij te geven.

Belangrijke kenmerken in coroutines:

• lock() niet-blokkerend (bij het verkrijgen van een vrije mutex): In tegenstelling tot traditionele threads, waar lock() de hele thread kan blokkeren, gebeurt de acquisitie in coroutines zonder blokkering als de mutex vrij is.
• Suspensie van de coroutine (bij bezette mutex): Als de mutex bezet is, blokkeert de aanroepende coroutine de thread niet, maar wordt onderbroken totdat deze wordt vrijgegeven. Dit geeft de thread de mogelijkheid om andere coroutines uit te voeren.
• Uitbreidingsfunctie withLock: Handige manier om de mutex te gebruiken, die deze automatisch verwerft en vrijgeeft, zelfs als er een uitzondering binnen het blok optreedt.

Voorbeeld van gebruik:

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

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        // Kritieke sectie - beschermde bron
        counter++
        delay(10) // Werk simulatie
        println("Counter: $counter")
    } // De mutex wordt hier automatisch vrijgegeven
}

fun main() = runBlocking {
    repeat(100) {
        launch {
            incrementCounter()
        }
    }
    delay(1000)
}

In dit voorbeeld is incrementCounter een kritieke sectie die de gedeelde bron counter wijzigt. De mutex garandeert dat slechts één coroutine tegelijk toegang heeft tot deze sectie, waardoor racecondities worden voorkomen. Het gebruik van withLock vereenvoudigt het beheer van de mutex.