Biztosítja az adatszerkezet a tömb biztonságát több szál egyidejű hozzáférése esetén?

Az iOS-ban lévő tömbök (például NSArray vagy Array Swift-ben) alapértelmezés szerint nem szálbiztosak. Ez azt jelenti, hogy több szálból történő egyidejű hozzáférés esetén, további szinkronizáció nélkül, versenyhelyzet alakulhat ki, ami kiszámíthatatlan viselkedést vagy az alkalmazás összeomlását eredményezheti.

A több szálon történő hozzáférés biztonságának biztosításához szinkronizációs mechanizmusokat kell alkalmazni, például DispatchQueue barierekkel, NSLock-kal vagy más szinkronizációs primitívekkel. Swift-ben szintén használható a DispatchQueue .concurrent attribútummal és a sync vagy async(flags: .barrier) módszerekkel biztonságos olvasáshoz és íráshoz.

Példa a DispatchQueue használatára szálbiztos tömbhozzáféréshez:

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

    func append(_ element: T) {
        queue.async(flags: .barrier) {
            self.array.append(element)
        }
    }

    func get(at index: Int) -> T? {
        var result: T?
        queue.sync {
            if index < self.array.count {
                result = self.array[index]
            }
        }
        return result
    }
}

Ezzel a módszerrel a tömbök önmagukban nem garantálják a biztonságot több szálról történő egyidejű hozzáférés esetén.