Kuidas sünkroniseerida andmeid niitide vahel ja…

Andmete sünkroniseerimiseks ja konteksti kooskõla tagamiseks mitme niidiga iOS rakenduses kasutatakse järgmisi lähenemisviise:

NSLock / Lock: Lihtsad lukud kriitiliste sektsioonide blokeerimiseks:

import Foundation

class ThreadSafeCounter {
    private var count: Int = 0
    private let lock = NSLock()

    func increment() {
        lock.lock()
        defer { lock.unlock() }
        count += 1
    }

    func getCount() -> Int {
        lock.lock()
        defer { lock.unlock() }
        return count
    }
}

NSRecursiveLock: Annab võimaluse sama niidi sees lukku uuesti haarata:

import Foundation

class RecursiveLocker {
    private let lock = NSRecursiveLock()

    func firstMethod() {
        lock.lock()
        defer { lock.unlock() }
        print("Esimene meetod")
        secondMethod() // Võimalik uuesti haarata
    }

    func secondMethod() {
        lock.lock()
        defer { lock.unlock() }
        print("Teine meetod")
    }
}

NSCondition / NSConditionLock: Annab võimaluse niitidel oodata teatud tingimust või väärtust enne jätkamist:

import Foundation

class Buffer {
    private var items: [Int] = []
    private let condition = NSCondition()
    private let capacity = 5

    func addItem(_ item: Int) {
        condition.lock()
        defer { condition.unlock() }

        while items.count == capacity {
            condition.wait() // Ootab, kuni vaba koht tekib
        }

        items.append(item)
        print("Lisatud: \(item), Praegune puffer: \(items)")
        condition.signal() // Signaalib ootavad niidid
    }

    func removeItem() -> Int {
        condition.lock()
        defer { condition.unlock() }

        while items.isEmpty {
            condition.wait() // Ootab, kuni element ilmub
        }

        let item = items.removeFirst()
        print("Eemaldatud: \(item), Praegune puffer: \(items)")
        condition.signal() // Signaalib ootavad niidid
        return item
    }
}

**Grand Central Dispatch (GCD):

Serial Queues: Täidavad ülesandeid järjekorras, üks korraga, tagades ressurssidele atomaarse juurdepääsu.

Concurrent Queues with Barrier Flags: Annab võimaluse lugeda samaaegselt, kuid kirjutamisoperatsioonid toimuvad eksklusiivselt:

import Foundation

class ThreadSafeArray<Element> {
    private var array: [Element] = []
    private let queue = DispatchQueue(label: "com.mycompany.threadsafearray", attributes: .concurrent) // Paralleelne järj

    func append(_ newElement: Element) {
        queue.async(flags: .barrier) { // Barrier kirjutamiseks
            self.array.append(newElement)
        }
    }

    func get(at index: Int) -> Element? {
        var result: Element?
        queue.sync { // Sünkroniseerimine lugemiseks
            if index < self.array.count {
                result = self.array[index]
            }
        }
        return result
    }
}

Core Data konteksti operatsioonid: Iga NSManagedObjectContext omab oma privaatset serialiseeritud voogu:

import CoreData

// Näide salvestamisest Core Data kontekstis
let context = // Saadud kontekst
context.perform { // Teostatakse eraldi konteksti voog
    // Töötamine Core Data objektidega
    do {
        try context.save()
    } catch {
        // Vea töötlemine
    }
}

Valik sõltub konkreetsest ülesandest ja jõudluse nõuetest. GCD-i serialiseeritud või paralleelne järjekord koos barjääridega on sageli kõige tõhusam ja kasutajasõbralik lähenemine. Core Data puhul kasutage kindlasti perform või performAndWait meetodeid.

Kuidas sünkroniseerida andmeid niitide vahel ja tagada konteksti järjepidevus?