Hogyan biztosítható a hozzáférés biztonsága egy tömbben több szál esetén?

Az iOS (Swift) több szálú környezetben általában szinkronizációs mechanizmusokat használnak az adatok versenyhelyzetének és sérülésének elkerülése érdekében.

Fő megközelítések:

1. Hozzáférés sorba rendezése DispatchQueue segítségével

let queue = DispatchQueue(label: "com.example.arrayQueue")
var array: [Int] = []

func appendElement(_ element: Int) {
    queue.sync {
        array.append(element)
    }
}

func getElement(at index: Int) -> Int? {
    return queue.sync {
        guard array.indices.contains(index) else { return nil }
        return array[index]
    }
}

2. NSLock vagy más zárolási primitív használata

let lock = NSLock()
var array: [Int] = []

func appendElement(_ element: Int) {
    lock.lock()
    array.append(element)
    lock.unlock()
}

3. Olvasási/írási műveletekhez közös zárolt sorozat (Dispatch barriers) használata

Ez lehetővé teszi az olvasást párhuzamosan, de az írás blokkolja a sort.

A kulcs az, hogy a hozzáférést a tömbhöz szinkronizációval ellenőrizzük, hogy elkerüljük a több szál által végrehajtott egyidejű módosításokat.