Wat doet synchronisatie in de context van multithreading?

Synchronisatie in de context van multithreading voorkomt race conditions en zorgt voor consistente toegang tot gedeelde bronnen (variabelen, bestanden, netwerkverbindingen) vanuit verschillende threads.

De belangrijkste synchronisatie-mechanismen:

• Mutex (mutual exclusion): Slechts één thread kan de mutex bezitten en toegang krijgen tot de beschermde bron.
• Semaphore (semafor): Beperkt het aantal threads dat gelijktijdig toegang kan krijgen tot een bron. Werkt met een teller.
• Lock (vergrendeling): Een algemeen begrip dat vaak wordt gebruikt om mutexen of andere mechanismen aan te duiden die volledige toegang blokkeren.
• Dispatch Queue (dispatch wachtrij): In Grand Central Dispatch (GCD) kunnen wachtrijen sequentieel (seri) of gelijktijdig (concurrent) zijn, en zorgen voor synchronisatie door de volgorde en het aantal gelijktijdige taken te beheren. Sequentiële wachtrijen garanderen dat taken één voor één worden uitgevoerd, wat inherent synchronisatie biedt voor gegevens die alleen vanuit de taken van die wachtrij toegankelijk zijn.

Werking principe: Een thread die toegang wil tot een gedeelde bron, probeert eerst een lock te verkrijgen. Als de bron vrij is, krijgt de thread de lock en werkt ermee. Na voltooiing geeft hij de lock vrij (release lock). Als de bron bezet is, worden andere threads geblokkeerd (wachten) totdat de bron wordt vrijgegeven.

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

// Voorbeeld in Objective-C met @synchronized
- (void)updateSharedResource {
    @synchronized (self) { // Lock op het object self
        // Hier wordt de kritieke sectie uitgevoerd
        // Toegang tot sharedResource is veilig
        self.sharedResource++;
    } // Lock wordt automatisch vrijgegeven bij het verlaten van het blok
}

// Voorbeeld in Swift met NSLock
let lock = NSLock()
var sharedCounter = 0

func incrementCounter() {
    lock.lock() // Proberen de lock te verkrijgen
    // Kritieke sectie
    sharedCounter += 1
    lock.unlock() // Lock vrijmaken
}

Synchronisatie helpt problemen zoals te voorkomen:

• Gegevenscorruptie.
• Deadlock (wachten op elkaar vastlopen).
• Livelock (actieve blokkades).

De keuze van het juiste synchronisatie-mechanisme hangt af van de aard van de taak en het type bron.