Wat is het verschil tussen een semaphore en een mutex?

Semafor is een algemeen synchronisatie-mechanisme dat wordt gebruikt om de toegang tot beperkte bronnen te beheren door meerdere concurrerende threads. Het houdt een gehele waarde bij die afneemt bij het verkrijgen van de bron en toeneemt bij het vrijgeven ervan. Als de waarde van de semafor nul is, blokkeert de poging om het te verkrijgen de thread totdat een andere thread de bron vrijgeeft. Het kan worden gebruikt om het aantal gelijktijdige werkende threads te beperken.

Een mutex (mutual exclusion) is een binaire semafor die zich in een geblokkeerde of ontblote staat kan bevinden. Het wordt gebruikt om kritieke secties van de code te beschermen tegen gelijktijdige toegang door meerdere threads. Slechts één thread kan de mutex op een gegeven moment verkrijgen. De thread die de mutex heeft verkregen, kan niet worden onderbroken door een andere thread die probeert het te verkrijgen. Als geprobeerd wordt een geblokkeerde mutex te verkrijgen, wordt de thread geblokkeerd tot deze wordt vrijgegeven.

Belangrijke verschillen:

Kenmerk	Semafor	Mutex
Type	Algemeen synchronisatie-mechanisme	Binaire semafor (speciaal geval van semafor)
Waarde	Geheel getal (>= 0)	Binaire (0 of 1)
Doel	Toegangscontrole tot bronnen, beperking van threads	Bescherming van kritieke secties, onderlinge uitsluiting
Eigenaar	Kan geen eigenaar hebben	Heeft altijd een eigenaar (thread die het heeft verkregen)
Gebruik in iOS	DispatchSemaphore	Vaak geïmplementeerd via DispatchQueue.sync of NSRecursiveLock in sommige scenario's

Voorbeeld van het gebruik van een mutex om een kritieke sectie te beschermen:

// In de context van GCD (Grand Central Dispatch)
let serialQueue = DispatchQueue(label: "com.example.criticalSection")

serialQueue.sync {
    // Kritieke code-sectie
    // Slechts één thread kan hier op elk moment zijn
}

Voorbeeld van het gebruik van een semafor om parallelle taken te beperken:

// In de context van GCD (Grand Central Dispatch)
let semaphore = DispatchSemaphore(value: 3) // Staat 3 gelijktijdige taken toe

DispatchQueue.global().async {
    semaphore.wait() // Verlaagt de waarde van de semafor met 1. Blokkeert als de waarde 0 is.

    // Code van de parallelle taak
    print("Taak wordt uitgevoerd")

    Thread.sleep(forTimeInterval: 1) // Werk simulatie

    semaphore.signal() // Verhoogt de waarde van de semafor met 1. Ontgrendelt de wachtende thread, indien aanwezig.
    print("Taak voltooid")
}

// Meerdere van dergelijke blokken kunnen worden gestart. Slechts 3 worden gelijktijdig uitgevoerd.