Wat is een deadlock?

Deadlock (Dodelock) is een toestand waarin twee of meer threads of processen elkaar blokkeren terwijl ze op elkaar wachten om door te gaan met uitvoeren. Dit gebeurt wanneer elke thread een resource bezit die door een andere thread nodig is, en wacht tot die resource wordt vrijgegeven.

Vier voorwaarden die nodig zijn voor het ontstaan van een deadlock (Coffman-voorwaarden):

1. Wederzijdse uitsluiting (Mutual Exclusion): De resource kan niet gelijktijdig door meerdere processen worden gebruikt.
2. Houden en wachten (Hold and Wait): Een thread die al minstens één resource bezit, wacht op aanvullende resources die door andere threads worden vastgehouden.
3. Geen preëmptie (No Preemption): Resources kunnen niet afgedwongen worden van een thread. Ze kunnen alleen vrijwillig worden vrijgegeven door de thread die ze bezit.
4. Circulaire wacht (Circular Wait): Er bestaat een cyclus van wachten tussen twee of meer threads. Bijvoorbeeld, thread A wacht op een resource die door thread B wordt vastgehouden, die op zijn beurt wacht op een resource die door thread C wordt vastgehouden, die op zijn beurt wacht op een resource die door thread A wordt vastgehouden.

In iOS-ontwikkeling komen deadlocks vaak voor bij het werken met concurrency, bijvoorbeeld bij verkeerd gebruik van GCD (Grand Central Dispatch) of Operation Queues:

• Een poging om een codeblok synchroon uit te voeren op een queue waar de huidige thread al op zit (bijvoorbeeld sync aanroepen op de main-queue vanuit de hoofdthread).
• Twee threads proberen twee locks of semaforen in verschillende volgorde te verkrijgen.

Voorbeeld van een eenvoudige deadlock met GCD:

func deadlockExample() {
    // Hoofdqueue
    let mainQueue = DispatchQueue.main

    // Voer een synchrone blok uit op de hoofdqueue vanuit de hoofdthread
    // De hoofdthread wacht op het einde van het blok,
    // en het blok kan niet worden uitgevoerd omdat de hoofdthread bezig is met wachten.
    mainQueue.sync {
        print("Deze regel wordt nooit bereikt.")
    }
}