Hoe implementeer je thread-safe interactie met mutabele gegevens in Swift? Beschrijf de benaderingen en de problemen die kunnen optreden bij onjuiste implementatie.

Antwoord

In Swift worden vaak GCD (Grand Central Dispatch) en queues (DispatchQueue), NSLock, en moderne mechanismen zoals actor (vanaf Swift 5.5) gebruikt om thread-safety te waarborgen.

Basale idee – toegang tot mutabele gegevens gebeurt ofwel strikt via sequentiële queues, of met behulp van synchronisatoren (locks).

Voorbeeld met GCD:

class ThreadSafeArray<Element> {
    private var array: [Element] = []
    private let queue = DispatchQueue(label: "com.example.arrayQueue", attributes: .concurrent)

    func append(_ item: Element) {
        queue.async(flags: .barrier) {
            self.array.append(item)
        }
    }

    func get(index: Int) -> Element? {
        var result: Element?
        queue.sync {
            result = self.array.indices.contains(index) ? self.array[index] : nil
        }
        return result
    }
}

Moderne benadering: Actors (Swift 5.5+):

actor SafeCounter {
    private var value = 0
    func increment() {
        value += 1
    }
    func get() -> Int {
        return value
    }
}

Beide benaderingen helpen om race conditions te vermijden en de consistentie van de toestand te waarborgen.

Misleidende vraag

Vraag:

Wat gebeurt er als je DispatchQueue.sync binnen de Main Queue gebruikt, en waarom?

Antwoord: Er ontstaat een deadlock omdat de Main Queue al een taak uitvoert en wacht op de voltooiing van de synchronisatie-operatie op dezelfde queue. Hierdoor kan de queue de volgende taak niet verwerken totdat de huidige is voltooid, wat nooit zal gebeuren.

Voorbeeld:

DispatchQueue.main.sync {
    // Deadlock: deze regel zal nooit worden uitgevoerd
}

Voorbeelden van echte fouten door gebrek aan kennis over de nuances van het onderwerp

---

Verhaal

In een project werd een mutabele collectie gebruikt die gelijktijdig door meerdere threads werd benaderd zonder synchronisatie. Dit leidde tot crashes van de applicatie en moeilijk te traceren bugs door race conditions: af en toe gingen elementen verloren, soms gebeurde er een out-of-bounds toegang tot de array.

---

Verhaal

Een ontwikkelaar gebruikte DispatchQueue.sync onjuist op de hoofdqueue in runtime, wat leidde tot deadlock en een volledige UI-stop voor gebruikers na de release van een update. Er was een dringende fix en roll-back van de release nodig.

---

Verhaal

Bij het proberen een klasse thread-safe te maken met NSLock, vergat men lock/unlock te implementeren voor alle uitgangspunten van de methode (bijvoorbeeld in het geval van een fout of return binnen een guard), wat leidde tot potentieel deadlocks en ernstige prestatieproblemen van de applicatie.